#!/usr/bin/env python #-*- coding:utf-8 -*- #--------------------------------------------------------------- # PyNLPl - Test Units for FoLiA # by Maarten van Gompel, ILK, Universiteit van Tilburg # http://ilk.uvt.nl/~mvgompel # proycon AT anaproy DOT nl # # Licensed under GPLv3 # #---------------------------------------------------------------- from __future__ import print_function from __future__ import unicode_literals from __future__ import division from __future__ import absolute_import import sys import os import unittest import io import gzip import bz2 import re from datetime import datetime import lxml.objectify from pynlpl.common import u, isstring from pynlpl.formats import folia if sys.version < '3': from codecs import getwriter stderr = getwriter('utf-8')(sys.stderr) stdout = getwriter('utf-8')(sys.stdout) else: stderr = sys.stderr stdout = sys.stdout FOLIARELEASE = "v1.5.1.60" #FOLIARELEASE = None #development version, do *NOT* release if this is set! if os.path.exists('../../../FoLiA'): FOLIAPATH = '../../../FoLiA/' elif os.path.exists('../../FoLiA'): FOLIAPATH = '../../FoLiA/' elif os.path.exists('../FoLiA'): FOLIAPATH = '../FoLiA/' else: FOLIAPATH = 'FoLiA' print("Downloading FoLiA",file=sys.stderr) if FOLIARELEASE: os.system("git clone https://github.com/proycon/folia.git FoLiA && cd FoLiA && git checkout tags/" + FOLIARELEASE + ' && cd ..') else: os.system("git clone https://github.com/proycon/folia.git FoLiA") if 'TMPDIR' in os.environ: TMPDIR = os.environ['TMPDIR'] else: TMPDIR = '/tmp/' if sys.version < '3': from StringIO import StringIO else: from io import StringIO, BytesIO if folia.LXE: from lxml import etree as ElementTree else: import xml.etree.cElementTree as ElementTree def xmlcheck(xml,expect): #obj1 = lxml.objectify.fromstring(expect) #expect = lxml.etree.tostring(obj1) f = io.open(os.path.join(TMPDIR, 'foliatest.fragment.expect.xml'),'w',encoding='utf-8') f.write(expect) f.close() f = io.open(os.path.join(TMPDIR , 'foliatest.fragment.out.xml'),'w', encoding='utf-8') f.write(xml) f.close() retcode = os.system('xmldiff -c ' + os.path.join(TMPDIR, 'foliatest.fragment.expect.xml') + ' ' + os.path.join(TMPDIR,'foliatest.fragment.out.xml')) passed = (retcode == 0) #obj2 = lxml.objectify.fromstring(xml) #xml = lxml.etree.tostring(obj2) #passed = (expect == xml) if not passed: print("XML fragments don't match:",file=stderr) print("--------------------------REFERENCE-------------------------------------",file=stderr) print(expect,file=stderr) print("--------------------------ACTUAL RESULT---------------------------------",file=stderr) print(xml,file=stderr) print("------------------------------------------------------------------------",file=stderr) return passed class Test1Read(unittest.TestCase): def test1_readfromfile(self): """Reading from file""" #write example to file f = io.open(os.path.join(TMPDIR,'foliatest.xml'),'w',encoding='utf-8') f.write(FOLIAEXAMPLE) f.close() doc = folia.Document(file=os.path.join(TMPDIR,'foliatest.xml')) self.assertTrue(isinstance(doc,folia.Document)) #sanity check: reading from file must yield the exact same data as reading from string doc2 = folia.Document(string=FOLIAEXAMPLE) self.assertEqual( doc, doc2) def test1a_readfromfile(self): """Reading from GZ file""" #write example to file f = gzip.GzipFile(os.path.join(TMPDIR,'foliatest.xml.gz'),'w') f.write(FOLIAEXAMPLE.encode('utf-8')) f.close() doc = folia.Document(file=os.path.join(TMPDIR,'foliatest.xml.gz')) self.assertTrue(isinstance(doc,folia.Document)) #sanity check: reading from file must yield the exact same data as reading from string doc2 = folia.Document(string=FOLIAEXAMPLE) self.assertEqual( doc, doc2) def test1b_readfromfile(self): """Reading from BZ2 file""" #write example to file f = bz2.BZ2File(os.path.join(TMPDIR,'foliatest.xml.bz2'),'w') f.write(FOLIAEXAMPLE.encode('utf-8')) f.close() doc = folia.Document(file=os.path.join(TMPDIR,'foliatest.xml.bz2')) self.assertTrue(isinstance(doc,folia.Document)) #sanity check: reading from file must yield the exact same data as reading from string doc2 = folia.Document(string=FOLIAEXAMPLE) self.assertEqual( doc, doc2) def test2_readfromstring(self): """Reading from string (unicode)""" doc = folia.Document(string=FOLIAEXAMPLE) self.assertTrue(isinstance(doc,folia.Document)) def test2b_readfromstring(self): """Reading from string (bytes)""" doc = folia.Document(string=FOLIAEXAMPLE.encode('utf-8')) self.assertTrue(isinstance(doc,folia.Document)) def test3_readfromstring(self): """Reading from pre-parsed XML tree (as unicode(Py2)/str(Py3) obj)""" if sys.version < '3': doc = folia.Document(tree=ElementTree.parse(StringIO(FOLIAEXAMPLE.encode('utf-8')))) else: doc = folia.Document(tree=ElementTree.parse(BytesIO(FOLIAEXAMPLE.encode('utf-8')))) self.assertTrue(isinstance(doc,folia.Document)) def test4_readdcoi(self): """Reading D-Coi file""" doc = folia.Document(string=DCOIEXAMPLE) #doc = folia.Document(tree=lxml.etree.parse(StringIO(DCOIEXAMPLE.encode('iso-8859-15')))) self.assertTrue(isinstance(doc,folia.Document)) self.assertEqual(len(list(doc.words())),1465) class Test2Sanity(unittest.TestCase): def setUp(self): self.doc = folia.Document(string=FOLIAEXAMPLE, textvalidation=True) def test000_count_text(self): """Sanity check - One text """ self.assertEqual( len(self.doc), 1) self.assertTrue( isinstance( self.doc[0], folia.Text )) def test001_count_paragraphs(self): """Sanity check - Paragraph count""" self.assertEqual( len(list(self.doc.paragraphs())) , 3) def test002_count_sentences(self): """Sanity check - Sentences count""" self.assertEqual( len(list(self.doc.sentences())) , 17) def test003a_count_words(self): """Sanity check - Word count""" self.assertEqual( len(list(self.doc.words())) , 190) def test003b_iter_words(self): """Sanity check - Words""" self.assertEqual( [x.id for x in self.doc.words() ], ['WR-P-E-J-0000000001.head.1.s.1.w.1', 'WR-P-E-J-0000000001.p.1.s.1.w.1', 'WR-P-E-J-0000000001.p.1.s.1.w.2', 'WR-P-E-J-0000000001.p.1.s.1.w.3', 'WR-P-E-J-0000000001.p.1.s.1.w.4', 'WR-P-E-J-0000000001.p.1.s.1.w.5', 'WR-P-E-J-0000000001.p.1.s.1.w.6', 'WR-P-E-J-0000000001.p.1.s.1.w.7', 'WR-P-E-J-0000000001.p.1.s.1.w.8', 'WR-P-E-J-0000000001.p.1.s.2.w.1', 'WR-P-E-J-0000000001.p.1.s.2.w.2', 'WR-P-E-J-0000000001.p.1.s.2.w.3', 'WR-P-E-J-0000000001.p.1.s.2.w.4', 'WR-P-E-J-0000000001.p.1.s.2.w.5', 'WR-P-E-J-0000000001.p.1.s.2.w.6', 'WR-P-E-J-0000000001.p.1.s.2.w.7', 'WR-P-E-J-0000000001.p.1.s.2.w.8', 'WR-P-E-J-0000000001.p.1.s.2.w.9', 'WR-P-E-J-0000000001.p.1.s.2.w.10', 'WR-P-E-J-0000000001.p.1.s.2.w.11', 'WR-P-E-J-0000000001.p.1.s.2.w.12', 'WR-P-E-J-0000000001.p.1.s.2.w.13', 'WR-P-E-J-0000000001.p.1.s.2.w.14', 'WR-P-E-J-0000000001.p.1.s.2.w.15', 'WR-P-E-J-0000000001.p.1.s.2.w.16', 'WR-P-E-J-0000000001.p.1.s.2.w.17', 'WR-P-E-J-0000000001.p.1.s.2.w.18', 'WR-P-E-J-0000000001.p.1.s.2.w.19', 'WR-P-E-J-0000000001.p.1.s.2.w.20', 'WR-P-E-J-0000000001.p.1.s.2.w.21', 'WR-P-E-J-0000000001.p.1.s.2.w.22', 'WR-P-E-J-0000000001.p.1.s.2.w.23', 'WR-P-E-J-0000000001.p.1.s.2.w.24-25', 'WR-P-E-J-0000000001.p.1.s.2.w.26', 'WR-P-E-J-0000000001.p.1.s.2.w.27', 'WR-P-E-J-0000000001.p.1.s.2.w.28', 'WR-P-E-J-0000000001.p.1.s.2.w.29', 'WR-P-E-J-0000000001.p.1.s.3.w.1', 'WR-P-E-J-0000000001.p.1.s.3.w.2', 'WR-P-E-J-0000000001.p.1.s.3.w.3', 'WR-P-E-J-0000000001.p.1.s.3.w.4', 'WR-P-E-J-0000000001.p.1.s.3.w.5', 'WR-P-E-J-0000000001.p.1.s.3.w.6', 'WR-P-E-J-0000000001.p.1.s.3.w.7', 'WR-P-E-J-0000000001.p.1.s.3.w.8', 'WR-P-E-J-0000000001.p.1.s.3.w.9', 'WR-P-E-J-0000000001.p.1.s.3.w.10', 'WR-P-E-J-0000000001.p.1.s.3.w.11', 'WR-P-E-J-0000000001.p.1.s.3.w.12', 'WR-P-E-J-0000000001.p.1.s.3.w.13', 'WR-P-E-J-0000000001.p.1.s.3.w.14', 'WR-P-E-J-0000000001.p.1.s.3.w.15', 'WR-P-E-J-0000000001.p.1.s.3.w.16', 'WR-P-E-J-0000000001.p.1.s.3.w.17', 'WR-P-E-J-0000000001.p.1.s.3.w.18', 'WR-P-E-J-0000000001.p.1.s.3.w.19', 'WR-P-E-J-0000000001.p.1.s.3.w.20', 'WR-P-E-J-0000000001.p.1.s.3.w.21', 'WR-P-E-J-0000000001.p.1.s.4.w.1', 'WR-P-E-J-0000000001.p.1.s.4.w.2', 'WR-P-E-J-0000000001.p.1.s.4.w.3', 'WR-P-E-J-0000000001.p.1.s.4.w.4', 'WR-P-E-J-0000000001.p.1.s.4.w.5', 'WR-P-E-J-0000000001.p.1.s.4.w.6', 'WR-P-E-J-0000000001.p.1.s.4.w.7', 'WR-P-E-J-0000000001.p.1.s.4.w.8', 'WR-P-E-J-0000000001.p.1.s.4.w.9', 'WR-P-E-J-0000000001.p.1.s.4.w.10', 'WR-P-E-J-0000000001.p.1.s.5.w.1', 'WR-P-E-J-0000000001.p.1.s.5.w.2', 'WR-P-E-J-0000000001.p.1.s.5.w.3', 'WR-P-E-J-0000000001.p.1.s.5.w.4', 'WR-P-E-J-0000000001.p.1.s.5.w.5', 'WR-P-E-J-0000000001.p.1.s.5.w.6', 'WR-P-E-J-0000000001.p.1.s.5.w.7', 'WR-P-E-J-0000000001.p.1.s.5.w.8', 'WR-P-E-J-0000000001.p.1.s.5.w.9', 'WR-P-E-J-0000000001.p.1.s.5.w.10', 'WR-P-E-J-0000000001.p.1.s.5.w.11', 'WR-P-E-J-0000000001.p.1.s.5.w.12', 'WR-P-E-J-0000000001.p.1.s.5.w.13', 'WR-P-E-J-0000000001.p.1.s.5.w.14', 'WR-P-E-J-0000000001.p.1.s.5.w.15', 'WR-P-E-J-0000000001.p.1.s.5.w.16', 'WR-P-E-J-0000000001.p.1.s.5.w.17', 'WR-P-E-J-0000000001.p.1.s.5.w.18', 'WR-P-E-J-0000000001.p.1.s.5.w.19', 'WR-P-E-J-0000000001.p.1.s.5.w.20', 'WR-P-E-J-0000000001.p.1.s.5.w.21', 'WR-P-E-J-0000000001.p.1.s.6.w.1', 'WR-P-E-J-0000000001.p.1.s.6.w.2', 'WR-P-E-J-0000000001.p.1.s.6.w.3', 'WR-P-E-J-0000000001.p.1.s.6.w.4', 'WR-P-E-J-0000000001.p.1.s.6.w.5', 'WR-P-E-J-0000000001.p.1.s.6.w.6', 'WR-P-E-J-0000000001.p.1.s.6.w.7', 'WR-P-E-J-0000000001.p.1.s.6.w.8', 'WR-P-E-J-0000000001.p.1.s.6.w.9', 'WR-P-E-J-0000000001.p.1.s.6.w.10', 'WR-P-E-J-0000000001.p.1.s.6.w.11', 'WR-P-E-J-0000000001.p.1.s.6.w.12', 'WR-P-E-J-0000000001.p.1.s.6.w.13', 'WR-P-E-J-0000000001.p.1.s.6.w.14', 'WR-P-E-J-0000000001.p.1.s.6.w.15', 'WR-P-E-J-0000000001.p.1.s.6.w.16', 'WR-P-E-J-0000000001.p.1.s.6.w.17', 'WR-P-E-J-0000000001.p.1.s.6.w.18', 'WR-P-E-J-0000000001.p.1.s.6.w.19', 'WR-P-E-J-0000000001.p.1.s.6.w.20', 'WR-P-E-J-0000000001.p.1.s.6.w.21', 'WR-P-E-J-0000000001.p.1.s.6.w.22', 'WR-P-E-J-0000000001.p.1.s.6.w.23', 'WR-P-E-J-0000000001.p.1.s.6.w.24', 'WR-P-E-J-0000000001.p.1.s.6.w.25', 'WR-P-E-J-0000000001.p.1.s.6.w.26', 'WR-P-E-J-0000000001.p.1.s.6.w.27', 'WR-P-E-J-0000000001.p.1.s.6.w.28', 'WR-P-E-J-0000000001.p.1.s.6.w.29', 'WR-P-E-J-0000000001.p.1.s.6.w.30', 'WR-P-E-J-0000000001.p.1.s.6.w.31', 'WR-P-E-J-0000000001.p.1.s.6.w.32', 'WR-P-E-J-0000000001.p.1.s.6.w.33', 'WR-P-E-J-0000000001.p.1.s.6.w.34', 'WR-P-E-J-0000000001.p.1.s.7.w.1', 'WR-P-E-J-0000000001.p.1.s.7.w.2', 'WR-P-E-J-0000000001.p.1.s.7.w.3', 'WR-P-E-J-0000000001.p.1.s.7.w.4', 'WR-P-E-J-0000000001.p.1.s.7.w.5', 'WR-P-E-J-0000000001.p.1.s.7.w.6', 'WR-P-E-J-0000000001.p.1.s.7.w.7', 'WR-P-E-J-0000000001.p.1.s.7.w.8', 'WR-P-E-J-0000000001.p.1.s.7.w.9', 'WR-P-E-J-0000000001.p.1.s.7.w.10', 'WR-P-E-J-0000000001.p.1.s.8.w.1', 'WR-P-E-J-0000000001.p.1.s.8.w.2', 'WR-P-E-J-0000000001.p.1.s.8.w.3', 'WR-P-E-J-0000000001.p.1.s.8.w.4', 'WR-P-E-J-0000000001.p.1.s.8.w.5', 'WR-P-E-J-0000000001.p.1.s.8.w.6', 'WR-P-E-J-0000000001.p.1.s.8.w.7', 'WR-P-E-J-0000000001.p.1.s.8.w.8', 'WR-P-E-J-0000000001.p.1.s.8.w.9', 'WR-P-E-J-0000000001.p.1.s.8.w.10', 'WR-P-E-J-0000000001.p.1.s.8.w.11', 'WR-P-E-J-0000000001.p.1.s.8.w.12', 'WR-P-E-J-0000000001.p.1.s.8.w.13', 'WR-P-E-J-0000000001.p.1.s.8.w.14', 'WR-P-E-J-0000000001.p.1.s.8.w.15', 'WR-P-E-J-0000000001.p.1.s.8.w.16', 'WR-P-E-J-0000000001.p.1.s.8.w.17', 'entry.1.term.1.w.1', 'sandbox.list.1.listitem.1.s.1.w.1', 'sandbox.list.1.listitem.1.s.1.w.2', 'sandbox.list.1.listitem.2.s.1.w.1', 'sandbox.list.1.listitem.2.s.1.w.2', 'sandbox.figure.1.caption.s.1.w.1', 'sandbox.figure.1.caption.s.1.w.2', 'WR-P-E-J-0000000001.sandbox.2.s.1.w.1', 'WR-P-E-J-0000000001.sandbox.2.s.1.w.2', 'WR-P-E-J-0000000001.sandbox.2.s.1.w.3', 'WR-P-E-J-0000000001.sandbox.2.s.1.w.4', 'WR-P-E-J-0000000001.sandbox.2.s.1.w.5', 'WR-P-E-J-0000000001.sandbox.2.s.1.w.6', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.1', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.2', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.3', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.4', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.5', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.6', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.7', 'WR-P-E-J-0000000001.sandbox.2.s.2.w.8', 'WR-P-E-J-0000000001.sandbox.2.s.3.w.1', 'WR-P-E-J-0000000001.sandbox.2.s.3.w.2', 'WR-P-E-J-0000000001.sandbox.2.s.3.w.3', 'WR-P-E-J-0000000001.sandbox.2.s.3.w.4', 'WR-P-E-J-0000000001.sandbox.2.s.3.w.6', 'example.table.1.w.1', 'example.table.1.w.2', 'example.table.1.w.3', 'example.table.1.w.4', 'example.table.1.w.5', 'example.table.1.w.6', 'example.table.1.w.7', 'example.table.1.w.8', 'example.table.1.w.9', 'example.table.1.w.10', 'example.table.1.w.11', 'example.table.1.w.12', 'example.table.1.w.13', 'example.table.1.w.14'] ) def test004_first_word(self): """Sanity check - First word""" #grab first word w = self.doc.words(0) # shortcut for doc.words()[0] self.assertTrue( isinstance(w, folia.Word) ) self.assertEqual( w.id , 'WR-P-E-J-0000000001.head.1.s.1.w.1' ) self.assertEqual( w.text() , "Stemma" ) self.assertEqual( str(w) , "Stemma" ) #should be unicode object also in Py2! if sys.version < '3': self.assertEqual( unicode(w) , "Stemma" ) #pylint: disable=undefined-variable def test005_last_word(self): """Sanity check - Last word""" #grab last word w = self.doc.words(-1) # shortcut for doc.words()[0] self.assertTrue( isinstance(w, folia.Word) ) self.assertEqual( w.id , "example.table.1.w.14" ) self.assertEqual( w.text() , "University" ) self.assertEqual( str(w) , "University" ) def test006_second_sentence(self): """Sanity check - Sentence""" #grab second sentence s = self.doc.sentences(1) self.assertTrue( isinstance(s, folia.Sentence) ) self.assertEqual( s.id, 'WR-P-E-J-0000000001.p.1.s.1' ) self.assertFalse( s.hastext() ) self.assertEqual( str(s), "Stemma is een ander woord voor stamboom." ) def test006b_sentencetest(self): """Sanity check - Sentence text (including retaining tokenisation)""" #grab second sentence s = self.doc['WR-P-E-J-0000000001.p.1.s.5'] self.assertTrue( isinstance(s, folia.Sentence) ) self.assertFalse( s.hastext() ) self.assertEqual( s.text(), "De andere handschriften krijgen ook een letter die verband kan houden met hun plaats van oorsprong óf plaats van bewaring.") self.assertEqual( s.text('current',True), "De andere handschriften krijgen ook een letter die verband kan houden met hun plaats van oorsprong óf plaats van bewaring .") #not detokenised self.assertEqual( s.toktext(), "De andere handschriften krijgen ook een letter die verband kan houden met hun plaats van oorsprong óf plaats van bewaring .") #just an alias for the above def test007_index(self): """Sanity check - Index""" #grab something using the index w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] self.assertTrue( isinstance(w, folia.Word) ) self.assertEqual( self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] , self.doc.index['WR-P-E-J-0000000001.p.1.s.2.w.7'] ) self.assertEqual( w.id , 'WR-P-E-J-0000000001.p.1.s.2.w.7' ) self.assertEqual( w.text() , "stamboom" ) def test008_division(self): """Sanity check - Division + head""" #grab something using the index div = self.doc['WR-P-E-J-0000000001.div0.1'] self.assertTrue( isinstance(div, folia.Division) ) self.assertEqual( div.head() , self.doc['WR-P-E-J-0000000001.head.1'] ) self.assertEqual( len(div.head()) ,1 ) #Head contains one element (one sentence) def test009_pos(self): """Sanity check - Token Annotation - Pos""" #grab first word w = self.doc.words(0) self.assertEqual( w.annotation(folia.PosAnnotation), next(w.select(folia.PosAnnotation)) ) #w.annotation() selects the single first annotation of that type, select is the generic method to retrieve pretty much everything self.assertTrue( isinstance(w.annotation(folia.PosAnnotation), folia.PosAnnotation) ) self.assertTrue( issubclass(folia.PosAnnotation, folia.AbstractTokenAnnotation) ) self.assertEqual( w.annotation(folia.PosAnnotation).cls, 'N(soort,ev,basis,onz,stan)' ) #cls is used everywhere instead of class, since class is a reserved keyword in python self.assertEqual( w.pos(),'N(soort,ev,basis,onz,stan)' ) #w.pos() is just a direct shortcut for getting the class self.assertEqual( w.annotation(folia.PosAnnotation).set, 'https://raw.githubusercontent.com/proycon/folia/master/setdefinitions/frog-mbpos-cgn' ) self.assertEqual( w.annotation(folia.PosAnnotation).annotator, 'frog' ) self.assertEqual( w.annotation(folia.PosAnnotation).annotatortype, folia.AnnotatorType.AUTO ) def test010_lemma(self): """Sanity check - Token Annotation - Lemma""" #grab first word w = self.doc.words(0) self.assertEqual( w.annotation(folia.LemmaAnnotation), w.annotation(folia.LemmaAnnotation) ) #w.lemma() is just a shortcut self.assertEqual( w.annotation(folia.LemmaAnnotation), next(w.select(folia.LemmaAnnotation)) ) #w.annotation() selects the single first annotation of that type, select is the generic method to retrieve pretty much everything self.assertTrue( isinstance(w.annotation(folia.LemmaAnnotation), folia.LemmaAnnotation)) self.assertEqual( w.annotation(folia.LemmaAnnotation).cls, 'stemma' ) self.assertEqual( w.lemma(),'stemma' ) #w.lemma() is just a direct shortcut for getting the class self.assertEqual( w.annotation(folia.LemmaAnnotation).set, 'lemmas-nl' ) self.assertEqual( w.annotation(folia.LemmaAnnotation).annotator, 'tadpole' ) self.assertEqual( w.annotation(folia.LemmaAnnotation).annotatortype, folia.AnnotatorType.AUTO ) def test011_tokenannot_notexist(self): """Sanity check - Token Annotation - Non-existing element""" #grab first word w = self.doc.words(0) self.assertEqual( w.count(folia.SenseAnnotation), 0) #list self.assertRaises( folia.NoSuchAnnotation, w.annotation, folia.SenseAnnotation) #exception def test012_correction(self): """Sanity check - Correction - Text""" w = self.doc['WR-P-E-J-0000000001.p.1.s.6.w.31'] c = w.annotation(folia.Correction) self.assertEqual( len(list(c.new())), 1) self.assertEqual( len(list(c.original())), 1) self.assertEqual( w.text(), 'vierkante') self.assertEqual( c.new(0), 'vierkante') self.assertEqual( c.original(0) , 'vierkant') def test013_correction(self): """Sanity check - Correction - Token Annotation""" w = self.doc['WR-P-E-J-0000000001.p.1.s.6.w.32'] c = w.annotation(folia.Correction) self.assertEqual( len(list(c.new())), 1) self.assertEqual( len(list(c.original())), 1) self.assertEqual( w.annotation(folia.LemmaAnnotation).cls , 'haak') self.assertEqual( c.new(0).cls, 'haak') self.assertEqual( c.original(0).cls, 'haaak') def test014_correction(self): """Sanity check - Correction - Suggestions (text)""" #grab first word w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.14'] c = w.annotation(folia.Correction) self.assertTrue( isinstance(c, folia.Correction) ) self.assertEqual( len(list(c.suggestions())), 2 ) self.assertEqual( str(c.suggestions(0).text()), 'twijfelachtige' ) self.assertEqual( str(c.suggestions(1).text()), 'ongewisse' ) def test015_parenttest(self): """Sanity check - Checking if all elements know who's their daddy""" def check(parent, indent = ''): for child in parent: if isinstance(child, folia.AbstractElement) and not (isinstance(parent, folia.AbstractSpanAnnotation) and (isinstance(child, folia.Word) or isinstance(child, folia.Morpheme))): #words and morphemes are exempted in abstractspanannotation #print indent + repr(child), child.id, child.cls self.assertTrue( child.parent is parent) check(child, indent + ' ') return True self.assertTrue( check(self.doc.data[0],' ') ) def test016a_description(self): """Sanity Check - Description""" w = self.doc['WR-P-E-J-0000000001.p.1.s.1.w.6'] self.assertEqual( w.description(), 'Dit woordje is een voorzetsel, het is maar dat je het weet...') def test016b_description(self): """Sanity Check - Error on non-existing description""" w = self.doc['WR-P-E-J-0000000001.p.1.s.1.w.7'] self.assertRaises( folia.NoSuchAnnotation, w.description) def test017_gap(self): """Sanity Check - Gap""" gap = self.doc["WR-P-E-J-0000000001.gap.1"] self.assertEqual( gap.content().strip()[:11], 'De tekst is') self.assertEqual( gap.cls, 'backmatter') self.assertEqual( gap.description(), 'Backmatter') def test018_subtokenannot(self): """Sanity Check - Subtoken annotation (part of speech)""" w= self.doc['WR-P-E-J-0000000001.p.1.s.2.w.5'] p = w.annotation(folia.PosAnnotation) self.assertEqual( p.feat('wvorm'), 'pv' ) self.assertEqual( p.feat('pvtijd'), 'tgw' ) self.assertEqual( p.feat('pvagr'), 'met-t' ) def test019_alignment(self): """Sanity Check - Alignment in same document""" w = self.doc['WR-P-E-J-0000000001.p.1.s.3.w.10'] a = w.annotation(folia.Alignment) target = next(a.resolve()) self.assertEqual( target, self.doc['WR-P-E-J-0000000001.p.1.s.3.w.5'] ) def test020a_spanannotation(self): """Sanity Check - Span Annotation (Syntax)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.1'] l = s.annotation(folia.SyntaxLayer) self.assertTrue( isinstance(l[0], folia.SyntacticUnit ) ) self.assertEqual( l[0].cls, 'sentence' ) self.assertEqual( l[0][0].cls, 'subject' ) self.assertEqual( l[0][0].text(), 'Stemma' ) self.assertEqual( l[0][1].cls, 'verb' ) self.assertEqual( l[0][2].cls, 'predicate' ) self.assertEqual( l[0][2][0].cls, 'np' ) self.assertEqual( l[0][2][1].cls, 'pp' ) self.assertEqual( l[0][2][1].text(), 'voor stamboom' ) self.assertEqual( l[0][2].text(), 'een ander woord voor stamboom' ) def test020b_spanannotation(self): """Sanity Check - Span Annotation (Chunking)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.1'] l = s.annotation(folia.ChunkingLayer) self.assertTrue( isinstance(l[0], folia.Chunk ) ) self.assertEqual( l[0].text(), 'een ander woord' ) self.assertEqual( l[1].text(), 'voor stamboom' ) def test020c_spanannotation(self): """Sanity Check - Span Annotation (Entities)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.1'] l = s.annotation(folia.EntitiesLayer) self.assertTrue( isinstance(l[0], folia.Entity) ) self.assertEqual( l[0].text(), 'ander woord' ) def test020d_spanannotation(self): """Sanity Check - Span Annotation (Dependencies)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.1'] l = s.annotation(folia.DependenciesLayer) self.assertTrue( isinstance(l[0], folia.Dependency) ) self.assertEqual( l[0].head().text(), 'is' ) self.assertEqual( l[0].dependent().text(), 'Stemma' ) self.assertEqual( l[0].cls, 'su' ) self.assertTrue( isinstance(l[1], folia.Dependency) ) self.assertEqual( l[1].head().text(), 'is' ) self.assertEqual( l[1].dependent().text(), 'woord' ) self.assertEqual( l[1].cls,'predc' ) self.assertTrue( isinstance(l[2], folia.Dependency) ) self.assertEqual( l[2].head().text(), 'woord' ) self.assertEqual( l[2].dependent().text(), 'een' ) self.assertEqual( l[2].cls,'det' ) self.assertTrue( isinstance(l[3], folia.Dependency) ) self.assertEqual( l[3].head().text(), 'woord' ) self.assertEqual( l[3].dependent().text(), 'ander' ) self.assertEqual( l[3].cls,'mod' ) self.assertTrue( isinstance(l[4], folia.Dependency) ) self.assertEqual( l[4].head().text(), 'woord' ) self.assertEqual( l[4].dependent().text(), 'voor' ) self.assertEqual( l[4].cls,'mod' ) self.assertTrue( isinstance(l[5], folia.Dependency) ) self.assertEqual( l[5].head().text(), 'voor' ) self.assertEqual( l[5].dependent().text(), 'stamboom' ) self.assertEqual( l[5].cls,'obj1' ) def test020e_spanannotation(self): """Sanity Check - Span Annotation (Timedevent)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.1'] l = s.annotation(folia.TimingLayer) self.assertTrue( isinstance(l[0], folia.TimeSegment ) ) self.assertEqual( l[0].text(), 'een ander woord' ) self.assertEqual( l[1].cls, 'cough' ) self.assertEqual( l[2].text(), 'voor stamboom' ) def test020f_spanannotation(self): """Sanity Check - Co-Reference""" div = self.doc["WR-P-E-J-0000000001.div0.1"] deplayer = div.annotation(folia.DependenciesLayer) deps = list(deplayer.annotations(folia.Dependency)) self.assertEqual( deps[0].cls, 'su' ) self.assertEqual( deps[1].cls, 'predc' ) self.assertEqual( deps[2].cls, 'det' ) self.assertEqual( deps[3].cls, 'mod' ) self.assertEqual( deps[4].cls, 'mod' ) self.assertEqual( deps[5].cls, 'obj1' ) self.assertEqual( deps[2].head().wrefs(0), self.doc['WR-P-E-J-0000000001.p.1.s.1.w.5'] ) self.assertEqual( deps[2].dependent().wrefs(0), self.doc['WR-P-E-J-0000000001.p.1.s.1.w.3'] ) def test020g_spanannotation(self): """Sanity Check - Semantic Role Labelling""" s = self.doc['WR-P-E-J-0000000001.p.1.s.7'] semrolelayer = s.annotation(folia.SemanticRolesLayer) predicate = semrolelayer.annotation(folia.Predicate) self.assertEqual( predicate.cls, 'aanduiden' ) roles = list(predicate.annotations(folia.SemanticRole)) self.assertEqual( roles[0].cls, 'actor' ) self.assertEqual( roles[1].cls, 'patient' ) self.assertEqual( roles[0].wrefs(0), self.doc['WR-P-E-J-0000000001.p.1.s.7.w.3'] ) self.assertEqual( roles[1].wrefs(0), self.doc['WR-P-E-J-0000000001.p.1.s.7.w.4'] ) self.assertEqual( roles[1].wrefs(1), self.doc['WR-P-E-J-0000000001.p.1.s.7.w.5'] ) def test021_previousword(self): """Sanity Check - Obtaining previous word""" w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] prevw = w.previous() self.assertTrue( isinstance(prevw, folia.Word) ) self.assertEqual( prevw.text(), "zo'n" ) def test021b_previousword_noscope(self): """Sanity Check - Obtaining previous word without scope constraint""" w = self.doc['WR-P-E-J-0000000001.p.1.s.4.w.1'] prevw = w.previous(folia.Word, None) self.assertTrue( isinstance(prevw, folia.Word) ) self.assertEqual( prevw.text(), "." ) def test021c_previousword_constrained(self): """Sanity Check - Obtaining non-existing previous word with scope constraint""" w = self.doc['WR-P-E-J-0000000001.p.1.s.4.w.1'] prevw = w.previous(folia.Word, [folia.Sentence]) self.assertEqual(prevw, None) def test022_nextword(self): """Sanity Check - Obtaining next word""" w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] nextw = w.next() self.assertTrue( isinstance(nextw, folia.Word) ) self.assertEqual( nextw.text(), "," ) def test023_leftcontext(self): """Sanity Check - Obtaining left context""" w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] context = w.leftcontext(3) self.assertEqual( [ x.text() for x in context ], ['wetenschap','wordt',"zo'n"] ) def test024_rightcontext(self): """Sanity Check - Obtaining right context""" w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] context = w.rightcontext(3) self.assertEqual( [ x.text() for x in context ], [',','onder','de'] ) def test025_fullcontext(self): """Sanity Check - Obtaining full context""" w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.7'] context = w.context(3) self.assertEqual( [ x.text() for x in context ], ['wetenschap','wordt',"zo'n",'stamboom',',','onder','de'] ) def test026_feature(self): """Sanity Check - Features""" w = self.doc['WR-P-E-J-0000000001.p.1.s.6.w.1'] pos = w.annotation(folia.PosAnnotation) self.assertTrue( isinstance(pos, folia.PosAnnotation) ) self.assertEqual(pos.cls,'WW(vd,prenom,zonder)') self.assertEqual( len(pos), 1) features = list(pos.select(folia.Feature)) self.assertEqual( len(features), 1) self.assertTrue( isinstance(features[0], folia.Feature)) self.assertEqual( features[0].subset, 'head') self.assertEqual( features[0].cls, 'WW') def test027_datetime(self): """Sanity Check - Time stamp""" w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.15'] pos = w.annotation(folia.PosAnnotation) self.assertEqual( pos.datetime, datetime(2011, 7, 20, 19, 0, 1) ) self.assertTrue( xmlcheck(pos.xmlstring(), '') ) def test028_wordparents(self): """Sanity Check - Finding parents of word""" w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.15'] s = w.sentence() self.assertTrue( isinstance(s, folia.Sentence) ) self.assertEqual( s.id, 'WR-P-E-J-0000000001.p.1.s.8') p = w.paragraph() self.assertTrue( isinstance(p, folia.Paragraph) ) self.assertEqual( p.id, 'WR-P-E-J-0000000001.p.1') div = w.division() self.assertTrue( isinstance(div, folia.Division) ) self.assertEqual( div.id, 'WR-P-E-J-0000000001.div0.1') self.assertEqual( w.incorrection(), None) def test0029_quote(self): """Sanity Check - Quote""" q = self.doc['WR-P-E-J-0000000001.p.1.s.8.q.1'] self.assertTrue( isinstance(q, folia.Quote) ) self.assertEqual(q.text(), 'volle lijn') s = self.doc['WR-P-E-J-0000000001.p.1.s.8'] self.assertEqual(s.text(), 'Een volle lijn duidt op een verwantschap , terweil een stippelijn op een onzekere verwantschap duidt .') #(spelling errors are present in sentence) #a word from the quote w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.2'] #check if sentence matches self.assertTrue( (w.sentence() is s) ) def test030_textcontent(self): """Sanity check - Text Content""" s = self.doc['WR-P-E-J-0000000001.p.1.s.4'] self.assertEqual( s.text(), 'De hoofdletter A wordt gebruikt voor het originele handschrift.') self.assertEqual( s.stricttext(), 'De hoofdletter A wordt gebruikt voor het originele handschrift.') self.assertEqual( s.textcontent().text(), 'De hoofdletter A wordt gebruikt voor het originele handschrift.') self.assertEqual( s.textcontent('original').text(), 'De hoofdletter A wordt gebruikt voor het originele handschrift.') self.assertRaises( folia.NoSuchText, s.text, 'BLAH' ) w = self.doc['WR-P-E-J-0000000001.p.1.s.4.w.2'] self.assertEqual( w.text(), 'hoofdletter') self.assertEqual( w.textcontent().text(), 'hoofdletter') self.assertEqual( w.textcontent().offset, 3) w2 = self.doc['WR-P-E-J-0000000001.p.1.s.6.w.31'] self.assertEqual( w2.text(), 'vierkante') self.assertEqual( w2.stricttext(), 'vierkante') def test030b_textcontent(self): """Sanity check - Text Content (2)""" s = self.doc['sandbox.3.head'] t = s.textcontent() self.assertEqual( len(t), 3) self.assertEqual( t.text(), "De \nFoLiA developers zijn:") self.assertEqual( t[0], "De ") self.assertTrue( isinstance(t[1], folia.TextMarkupString) ) self.assertEqual( t[1].text(), "\nFoLiA developers") self.assertEqual( t[2], " zijn:") def test030c_textclassattrib(self): """Sanity check - Text class attribute""" w = self.doc['WR-P-E-J-0000000001.p.1.s.4.w.5'] self.assertEqual( w.annotation(folia.PosAnnotation).textclass , 'original') self.assertEqual( w.annotation(folia.LemmaAnnotation).textclass , 'original') def test030d_textclassattrib_default(self): """Sanity check - Text class attribute (default)""" w = self.doc['WR-P-E-J-0000000001.p.1.s.4.w.4'] self.assertEqual( w.annotation(folia.PosAnnotation).textclass , 'current') self.assertEqual( w.annotation(folia.LemmaAnnotation).textclass , 'current') def test031_sense(self): """Sanity Check - Lexical Semantic Sense Annotation""" w = self.doc['sandbox.list.1.listitem.1.s.1.w.1'] sense = w.annotation(folia.SenseAnnotation) self.assertEqual( sense.cls , 'some.sense.id') self.assertEqual( sense.feat('synset') , 'some.synset.id') def test032_event(self): """Sanity Check - Events""" l= self.doc['sandbox'] event = l.annotation(folia.Event) self.assertEqual( event.cls , 'applause') self.assertEqual( event.feat('actor') , 'audience') def test033_list(self): """Sanity Check - List""" l = self.doc['sandbox.list.1'] self.assertTrue( isinstance( l[0], folia.ListItem) ) self.assertEqual( l[0].n, '1' ) #testing common n attribute self.assertEqual( l[0].text(), 'Eerste testitem') self.assertTrue( isinstance( l[-1], folia.ListItem) ) self.assertEqual( l[1].text(), 'Tweede testitem') self.assertEqual( l[1].n, '2' ) def test034_figure(self): """Sanity Check - Figure""" fig = self.doc['sandbox.figure.1'] self.assertEqual( fig.src, "http://upload.wikimedia.org/wikipedia/commons/8/8e/Family_tree.svg") self.assertEqual( fig.caption(), 'Een stamboom') def test035_event(self): """Sanity Check - Event""" e = self.doc['sandbox.event.1'] self.assertEqual( e.feat('actor'), 'proycon') self.assertEqual( e.feat('begindatetime'), '2011-12-15T19:01') self.assertEqual( e.feat('enddatetime'), '2011-12-15T19:05') def test036_parsen(self): """Sanity Check - Paragraph and Sentence annotation""" p = self.doc['WR-P-E-J-0000000001.p.1'] self.assertEqual( p.cls, 'firstparagraph' ) s = self.doc['WR-P-E-J-0000000001.p.1.s.6'] self.assertEqual( s.cls, 'sentence' ) def test037a_feat(self): """Sanity Check - Feature test (including shortcut)""" xml = """
blah

blah

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc['head.1.s.1.w.1'].pos() , 'NN(blah)') self.assertEqual( doc['head.1.s.1.w.1'].annotation(folia.PosAnnotation).feat('head') , 'NN') self.assertEqual( doc['p.1.s.1.w.1'].pos() , 'NN(blah)') self.assertEqual( doc['p.1.s.1.w.1'].annotation(folia.PosAnnotation).feat('head') , 'NN') def test037b_multiclassfeat(self): """Sanity Check - Multiclass feature""" xml = """

blah

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc['p.1.s.1.w.1'].pos() , 'NN(a,b,c)') self.assertEqual( doc['p.1.s.1.w.1'].annotation(folia.PosAnnotation).feat('x') , ['a','b','c'] ) def test038a_morphemeboundary(self): """Sanity check - Obtaining annotation should not descend into morphology layer""" self.assertRaises( folia.NoSuchAnnotation, self.doc['WR-P-E-J-0000000001.sandbox.2.s.1.w.2'].annotation , folia.PosAnnotation) def test038b_morphemeboundary(self): """Sanity check - Obtaining morphemes and token annotation under morphemes""" w = self.doc['WR-P-E-J-0000000001.sandbox.2.s.1.w.2'] l = list(w.morphemes()) #get all morphemes self.assertEqual(len(l), 2) m = w.morpheme(1) #get second morpheme self.assertEqual(m.annotation(folia.PosAnnotation).cls, 'n') def test039_findspan(self): """Sanity Check - Find span on layer""" s = self.doc['WR-P-E-J-0000000001.p.1.s.7'] semrolelayer = s.annotation(folia.SemanticRolesLayer) roles = list(semrolelayer.annotations(folia.SemanticRole)) self.assertEqual(semrolelayer.findspan( self.doc['WR-P-E-J-0000000001.p.1.s.7.w.4'], self.doc['WR-P-E-J-0000000001.p.1.s.7.w.5']), roles[1] ) def test040_spaniter(self): """Sanity Check - Iteration over spans""" t = [] sentence = self.doc["WR-P-E-J-0000000001.p.1.s.1"] for layer in sentence.select(folia.EntitiesLayer): for entity in layer.select(folia.Entity): for word in entity.wrefs(): t.append(word.text()) self.assertEqual(t, ['ander','woord']) def test041_findspans(self): """Sanity check - Find spans given words (no set)""" t = [] word = self.doc["WR-P-E-J-0000000001.p.1.s.1.w.4"] for entity in word.findspans(folia.EntitiesLayer): for word in entity.wrefs(): t.append(word.text()) self.assertEqual(t, ['ander','woord']) def test041b_findspans(self): """Sanity check - Find spans given words (specific set)""" t = [] word = self.doc["example.table.1.w.3"] for entity in word.findspans(folia.EntitiesLayer, "http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml"): for word in entity.wrefs(): t.append(word.text()) self.assertEqual(t, ['Maarten','van','Gompel']) def test041c_findspans(self): """Sanity check - Find spans given words (specific set, by SpanAnnotation class)""" t = [] word = self.doc["example.table.1.w.3"] for entity in word.findspans(folia.Entity, "http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml"): for word in entity.wrefs(): t.append(word.text()) self.assertEqual(t, ['Maarten','van','Gompel']) def test042_table(self): """Sanity check - Table""" table = self.doc["example.table.1"] self.assertTrue( isinstance(table, folia.Table)) self.assertTrue( isinstance(table[0], folia.TableHead)) self.assertTrue( isinstance(table[0][0], folia.Row)) self.assertEqual( len(table[0][0]), 2) #two cells self.assertTrue( isinstance(table[0][0][0], folia.Cell)) self.assertEqual( table[0][0][0].text(), "Naam" ) self.assertEqual( table[0][0].text(), "Naam | Universiteit" ) #text of whole row def test043_string(self): """Sanity check - String""" s = self.doc["sandbox.3.head"] self.assertTrue( s.hasannotation(folia.String) ) st = next(s.select(folia.String)) self.assertEqual( st.text(), "FoLiA developers") self.assertEqual( st.annotation(folia.LangAnnotation).cls, "eng") def test044_textmarkup(self): """Sanity check - Text Markup""" s = self.doc["sandbox.3.head"] t = s.textcontent() self.assertEqual( s.count(folia.TextMarkupString), 1) self.assertEqual( t.count(folia.TextMarkupString), 1) st = next(t.select(folia.TextMarkupString)) self.assertEqual( st.text(), "\nFoLiA developers" ) #testing value (full text value) self.assertEqual( st.resolve(), self.doc['sandbox.3.str']) #testing resolving references self.assertTrue( isinstance( self.doc['WR-P-E-J-0000000001.p.1.s.6'].textcontent()[-1], folia.Linebreak) ) #did we get the linebreak properly? #testing nesting self.assertEqual( len(st), 2) self.assertEqual( st[0], self.doc['sandbox.3.str.bold']) #testing TextMarkup.text() self.assertEqual( st[0].text(), '\nFoLiA' ) #resolving returns self if it's not a reference self.assertEqual( self.doc['sandbox.3.str.bold'].resolve(), self.doc['sandbox.3.str.bold']) def test045_spancorrection(self): """Sanity Check - Corrections over span elements""" s = self.doc['example.last.cell'] entities = list(s.select(folia.Entity,set="http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml")) self.assertEqual( len(entities),1 ) self.assertEqual( entities[0].id , "example.tilburg.university.org" ) def test046_entry(self): """Sanity Check - Checking entry, term, definition and example""" entry = self.doc['entry.1'] terms = list(entry.select(folia.Term)) self.assertEqual( len(terms),1 ) self.assertEqual( terms[0].text() ,"Stemma" ) definitions = list(entry.select(folia.Definition)) self.assertEqual( len(definitions),2 ) examples = list(entry.select(folia.Example)) self.assertEqual( len(examples),1 ) def test046a_text(self): """Sanity Check - Text serialisation test with linebreaks and whitespaces""" p = self.doc['WR-P-E-J-0000000001.p.1'] #this is a bit of a malformed paragraph due to the explicit whitespace and linebreaks in it, but makes for a nice test: self.maxDiff = 3000 self.assertEqual( p.text(), "Stemma is een ander woord voor stamboom. In de historische wetenschap wordt zo'n stamboom , onder de naam stemma codicum ( handschriftelijke genealogie ) , gebruikt om de verwantschap tussen handschriften weer te geven . \n\nWerkwijze\n\nHiervoor worden de handschriften genummerd en gedateerd zodat ze op de juiste plaats van hun afstammingsgeschiedenis geplaatst kunnen worden . De hoofdletter A wordt gebruikt voor het originele handschrift. De andere handschriften krijgen ook een letter die verband kan houden met hun plaats van oorsprong óf plaats van bewaring. Verdwenen handschriften waarvan men toch vermoedt dat ze ooit bestaan hebben worden ook in het stemma opgenomen en worden weergegeven door de laatste letters van het alfabet en worden tussen vierkante haken geplaatst.\nTenslotte gaat men de verwantschap tussen de handschriften aanduiden . Een volle lijn duidt op een verwantschap , terweil een stippelijn op een onzekere verwantschap duidt .") def test046b_text(self): """Sanity Check - Text serialisation on lists""" l = self.doc['sandbox.list.1'] #this is a bit of a malformed paragraph due to the explicit whitespace and linebreaks in it, but makes for a nice test: self.assertEqual( l.text(), "Eerste testitem\nTweede testitem") def test047_alignment(self): """Sanity check - Alignment""" word = self.doc['WR-P-E-J-0000000001.p.1.s.3.w.10'] a = word.annotation(folia.Alignment) self.assertEqual( a.cls, "reference") aref = next(a.select(folia.AlignReference,ignore=False)) self.assertEqual( aref.id,"WR-P-E-J-0000000001.p.1.s.3.w.5" ) self.assertEqual( aref.type, 'w' ) self.assertEqual( aref.t,"handschriften" ) def test048_observations(self): """Sanity check - Observations""" word = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.9'] observation = list(word.findspans(folia.ObservationLayer))[0] self.assertEqual( observation.cls , "ei_ij_error") self.assertEqual( observation.description() , "Confusion between EI and IJ diphtongues") def test049_sentiment(self): """Sanity check - Sentiments""" sentence = self.doc['WR-P-E-J-0000000001.sandbox.2.s.3'] sentiments = sentence.annotation(folia.SentimentLayer) sentiment = sentiments.annotation(folia.Sentiment) self.assertEqual( sentiment.cls , "disappointment") self.assertEqual( sentiment.feat('polarity') , "negative") self.assertEqual( sentiment.feat('strength') , "strong") self.assertEqual( sentiment.annotation(folia.Source).text(), "Hij") self.assertEqual( sentiment.annotation(folia.Headspan).text(), "erg teleurgesteld") def test050_statement(self): """Sanity check - Statements""" sentence = self.doc['WR-P-E-J-0000000001.sandbox.2.s.2'] sentiments = sentence.annotation(folia.StatementLayer) sentiment = sentiments.annotation(folia.Statement) self.assertEqual( sentiment.cls , "promise") self.assertEqual( sentiment.annotation(folia.Source).text(), "Hij") self.assertEqual( sentiment.annotation(folia.Relation).text(), "had beloofd") self.assertEqual( sentiment.annotation(folia.Headspan).text(), "hij zou winnen") def test099_write(self): """Sanity Check - Writing to file""" self.doc.save(os.path.join(TMPDIR,'foliasavetest.xml')) def test099b_write(self): """Sanity Check - Writing to GZ file""" self.doc.save(os.path.join(TMPDIR,'foliasavetest.xml.gz')) def test099c_write(self): """Sanity Check - Writing to BZ2 file""" self.doc.save(os.path.join(TMPDIR,'foliasavetest.xml.bz2')) def test100a_sanity(self): """Sanity Check - A - Checking output file against input (should be equal)""" f = io.open(os.path.join(TMPDIR,'foliatest.xml'),'w',encoding='utf-8') f.write(FOLIAEXAMPLE) f.close() self.doc.save(os.path.join(TMPDIR,'foliatest100.xml')) self.assertEqual( folia.Document(file=os.path.join(TMPDIR,'foliatest100.xml'),debug=False), self.doc ) def test100b_sanity_xmldiff(self): """Sanity Check - B - Checking output file against input using xmldiff (should be equal)""" f = io.open(os.path.join(TMPDIR,'foliatest.xml'),'w',encoding='utf-8') f.write(FOLIAEXAMPLE) f.close() #use xmldiff to compare the two: self.doc.save(os.path.join(TMPDIR,'foliatest100.xml')) retcode = os.system('xmldiff -c ' + os.path.join(TMPDIR,'foliatest.xml') + ' ' + os.path.join(TMPDIR,'foliatest100.xml')) #retcode = 1 #disabled (memory hog) self.assertEqual( retcode, 0) def test101a_metadataextref(self): """Sanity Check - Metadata external reference (CMDI)""" xml = """ """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.metadatatype, folia.MetaDataType.CMDI ) self.assertEqual( doc.metadata.url, 'test.cmdi.xml' ) def test101b_metadataextref2(self): """Sanity Check - Metadata external reference (IMDI)""" xml = """ """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.metadatatype, folia.MetaDataType.IMDI ) self.assertEqual( doc.metadata.url , 'test.imdi.xml' ) def test101c_metadatainternal(self): """Sanity Check - Metadata internal (foreign data) (Dublin Core)""" xml = """ mydoc text/xml Example proycon proycon en Radboud University public Domain """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.metadatatype, "dc" ) self.assertEqual( doc.metadata.node.xpath('//dc:creator', namespaces={'dc':'http://purl.org/dc/elements/1.1/'})[0].text , 'proycon' ) xmlcheck(doc.xmlstring(), xml) def test101d_metadatainternal(self): """Sanity Check - Metadata internal (double)""" xml = """ mydoc text/xml Example proycon proycon en Radboud University public Domain """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.metadatatype, "dc" ) self.assertEqual( doc.metadata.node.xpath('//dc:creator', namespaces={'dc':'http://purl.org/dc/elements/1.1/'})[0].text , 'proycon' ) xmlcheck(doc.xmlstring(), xml) def test101e_metadatalegacyimdi(self): """Sanity Check - Legacy inline IMDI metadata""" #adapted from foliatests/tests/folia.imdi.xml xml = """ Een imdi file 28/09/2017 """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.metadatatype, "imdi" ) self.assertEqual( doc.metadata.node.xpath('//imdi:Title', namespaces={'imdi':'http://www.mpi.nl/IMDI/Schema/IMDI'})[0].text , 'Een imdi file' ) def test102a_declarations(self): """Sanity Check - Declarations - Default set""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( next(doc['example.text.1'].select(folia.Gap)).set, 'gap-set' ) def test102a2_declarations(self): """Sanity Check - Declarations - Default set, no further defaults""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( next(doc['example.text.1'].select(folia.Gap)).set, 'gap-set' ) self.assertEqual( next(doc['example.text.1'].select(folia.Gap)).annotator, 'proycon' ) self.assertEqual( next(doc['example.text.1'].select(folia.Gap)).annotatortype, folia.AnnotatorType.MANUAL) def test102b_declarations(self): """Sanity Check - Declarations - Set mismatching """ xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) with self.assertRaises( folia.ParseError) as cm: folia.Document(string=xml) self.assertEqual(cm.exception.cause.__class__, ValueError) def test102c_declarations(self): """Sanity Check - Declarations - Multiple sets for the same annotation type""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( next(doc['example.text.1'].select(folia.Gap)).set, 'gap-set' ) self.assertEqual( list(doc['example.text.1'].select(folia.Gap))[1].set, 'extended-gap-set' ) def test102d1_declarations(self): """Sanity Check - Declarations - Multiple sets for the same annotation type (testing failure)""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) with self.assertRaises( folia.ParseError) as cm: folia.Document(string=xml) self.assertEqual(cm.exception.cause.__class__, ValueError) def test102d2_declarations(self): """Sanity Check - Declarations - Multiple sets for the same annotation type (testing failure)""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) with self.assertRaises( folia.ParseError) as cm: folia.Document(string=xml) self.assertEqual(cm.exception.cause.__class__, ValueError) def test102d3_declarations(self): """Sanity Check - Declarations - Ignore Duplicates""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.defaultset(folia.AnnotationType.GAP), 'gap-set' ) self.assertEqual( doc.defaultannotator(folia.AnnotationType.GAP), "sloot" ) def test102e_declarations(self): """Sanity Check - Declarations - Missing declaration""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) with self.assertRaises( folia.ParseError) as cm: folia.Document(string=xml) self.assertEqual(cm.exception.cause.__class__, ValueError) def test102f_declarations(self): """Sanity Check - Declarations - Declaration not needed""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) folia.Document(string=xml) def test102g_declarations(self): """Sanity Check - Declarations - 'Undefined' set in declaration""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( next(doc['example.text.1'].select(folia.Gap)).set, 'undefined' ) def test102h_declarations(self): """Sanity Check - Declarations - Double ambiguous declarations unset default""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertRaises(folia.NoDefaultError, doc.defaultannotator, folia.AnnotationType.GAP) def test102i_declarations(self): """Sanity Check - Declarations - miscellaneous trouble""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.defaultannotator(folia.AnnotationType.GAP,"gap1-set"), "sloot" ) doc.declare(folia.AnnotationType.GAP, "gap1-set", annotator='proycon' ) #slightly different behaviour from libfolia: here this overrides the earlier default self.assertEqual( doc.defaultannotator(folia.AnnotationType.GAP,"gap1-set"), "proycon" ) self.assertEqual( doc.defaultannotator(folia.AnnotationType.GAP,"gap2-set"), "sloot" ) text = doc["example.text.1"] text.append( folia.Gap(doc, set='gap1-set', cls='Y', annotator='proycon') ) text.append( folia.Gap(doc, set='gap1-set', cls='Z1' ) ) text.append( folia.Gap(doc, set='gap2-set', cls='Z2' ) ) text.append( folia.Gap(doc, set='gap2-set', cls='Y2', annotator='onbekend' ) ) gaps = list(text.select(folia.Gap)) self.assertTrue( xmlcheck(gaps[0].xmlstring(), '' ) ) self.assertTrue( xmlcheck(gaps[1].xmlstring(), '') ) self.assertTrue( xmlcheck(gaps[2].xmlstring(), '') ) self.assertTrue( xmlcheck(gaps[3].xmlstring(), '') ) self.assertTrue( xmlcheck(gaps[4].xmlstring(), '') ) def test102j_declarations(self): """Sanity Check - Declarations - Adding a declaration in other set.""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) text = doc["example.text.1"] doc.declare(folia.AnnotationType.GAP, "other-set", annotator='proycon' ) text.append( folia.Gap(doc, set='other-set', cls='Y', annotator='proycon') ) text.append( folia.Gap(doc, set='other-set', cls='Z' ) ) gaps = list(text.select(folia.Gap)) self.assertEqual( gaps[0].xmlstring(), '' ) self.assertEqual( gaps[1].xmlstring(), '' ) self.assertEqual( gaps[2].xmlstring(), '' ) def test102k_declarations(self): """Sanity Check - Declarations - Several annotator types.""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.defaultannotatortype(folia.AnnotationType.GAP, 'gap-set'), folia.AnnotatorType.AUTO) text = doc["example.text.1"] gaps = list(text.select(folia.Gap)) self.assertTrue( xmlcheck(gaps[0].xmlstring(), '' ) ) doc.declare(folia.AnnotationType.GAP, "gap-set", annotatortype=folia.AnnotatorType.MANUAL ) self.assertEqual( doc.defaultannotatortype(folia.AnnotationType.GAP), folia.AnnotatorType.MANUAL ) self.assertRaises( ValueError, folia.Gap, doc, set='gap-set', cls='Y', annotatortype='unknown' ) text.append( folia.Gap(doc, set='gap-set', cls='Y', annotatortype='manual' ) ) text.append( folia.Gap(doc, set='gap-set', cls='Z', annotatortype='auto' ) ) gaps = list(text.select(folia.Gap)) self.assertTrue( xmlcheck(gaps[0].xmlstring(), '') ) self.assertTrue( xmlcheck(gaps[1].xmlstring(), '') ) self.assertTrue( xmlcheck(gaps[2].xmlstring(), '') ) def test102l_declarations(self): """Sanity Check - Declarations - Datetime default.""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.defaultdatetime(folia.AnnotationType.GAP, 'gap-set'), folia.parse_datetime('2011-12-15T19:00') ) self.assertEqual( next(doc["example.text.1"].select(folia.Gap)).datetime , folia.parse_datetime('2011-12-15T19:00') ) def test102m_declarations(self): """Sanity Check - Declarations - Adding a declaration of a FoLiA v1.4 RDF Set Definition.""" xml = """\n """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) doc.declare(folia.AnnotationType.ENTITY, "https://github.com/proycon/folia/blob/master/setdefinitions/namedentities.foliaset.ttl", annotator='proycon' ) def test102n_aliases(self): """Sanity Check - Declarations - Testing Aliases""" xml = """ n" n" """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) doc.declare(folia.AnnotationType.GAP, "nog zon ingewikkelde en veels te lange declaratie", alias='gap-set2' ) self.doc.xmlstring() #check if serialisation works #declaring a setname which is already an alias is an error self.assertRaises( ValueError, doc.declare, folia.AnnotationType.GAP, "gap-set2") #declaring an alias which is already an alias is an error self.assertRaises( ValueError, doc.declare, folia.AnnotationType.GAP, "gap-set3", alias="gap-set2") #declaring an alias which is already a setname is an error self.assertRaises( ValueError, doc.declare, folia.AnnotationType.GAP, "gap-set3", alias="nog zon ingewikkelde en veels te lange declaratie") #just declaring again is NOT an error! doc.declare(folia.AnnotationType.GAP, "nog zon ingewikkelde en veels te lange declaratie", alias='gap-set2' ) self.doc.xmlstring() #check if serialisation still works #declaring again with another alias IS an error! self.assertRaises(ValueError, doc.declare,folia.AnnotationType.GAP, "nog zon ingewikkelde en veels te lange declaratie", alias='gap-set3' ) #declaring again with same alias and another setname IS an error! self.assertRaises(ValueError, doc.declare, folia.AnnotationType.GAP, "niet zon ingewikkelde en veels te lange declaratie", alias='gap-set2' ) def test103_namespaces(self): """Sanity Check - Alien namespaces - Checking whether properly ignored""" xml = """\n blah word """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertTrue( len(list(doc['example.text.1.s.1'].words())) == 1 ) #second word is in alien namespace, not read self.assertRaises( KeyError, doc.__getitem__, 'example.text.1.s.1.alienword') #doesn't exist def test104_speech(self): """Sanity Check - Speech data (without attributes)""" xml = """\n həlˈəʊ wˈɜːld həlˈəʊ wˈɜːld """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertTrue( isinstance(doc.data[0], folia.Speech) ) self.assertTrue( isinstance(doc['example.speech.utt.1'], folia.Utterance) ) self.assertEqual( doc['example.speech.utt.1'].phon(), "həlˈəʊ wˈɜːld" ) self.assertRaises( folia.NoSuchText, doc['example.speech.utt.1'].text) #doesn't exist self.assertEqual( doc['example.speech.utt.2'].phon(), "həlˈəʊ wˈɜːld" ) def test104b_speech(self): """Sanity Check - Speech data with speech attributes""" xml = """\n həlˈəʊ wˈɜːld həlˈəʊ wˈɜːld """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertTrue( isinstance(doc.data[0], folia.Speech) ) self.assertTrue( isinstance(doc['example.speech.utt.1'], folia.Utterance) ) self.assertEqual( doc['example.speech.utt.1'].phon(), "həlˈəʊ wˈɜːld" ) self.assertRaises( folia.NoSuchText, doc['example.speech.utt.1'].text) #doesn't exist self.assertEqual( doc['example.speech.utt.2'].phon(), "həlˈəʊ wˈɜːld" ) self.assertEqual( doc['example.speech'].speech_speaker(), "proycon" ) self.assertEqual( doc['example.speech'].speech_src(), "helloworld.ogg" ) self.assertEqual( doc['example.speech.utt.1'].begintime, (0,0,0,0) ) self.assertEqual( doc['example.speech.utt.1'].endtime, (0,0,2,12) ) #testing inheritance self.assertEqual( doc['example.speech.utt.2.w.2'].speech_speaker(), "proycon" ) self.assertEqual( doc['example.speech.utt.2.w.2'].speech_src(), "helloworld.ogg" ) self.assertEqual( doc['example.speech.utt.2.w.2'].begintime, (0,0,1,267) ) self.assertEqual( doc['example.speech.utt.2.w.2'].endtime, (0,0,2,12) ) def test104c_speech(self): """Sanity Check - Testing serialisation of speech data with speech attributes""" speechxml = """ həlˈəʊ wˈɜːld həlˈəʊ wˈɜːld """ xml = """\n %s """ % speechxml doc = folia.Document(string=xml) self.assertTrue( xmlcheck( doc['example.speech'].xmlstring(), u(speechxml)) ) def test105_complexalignment(self): """Sanity Check - Complex alignment""" xml = """

Dit is een test. Ik wil kijken of het werkt.

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertTrue(doc.xml() is not None) #serialisation check l = doc.paragraphs(0).annotation(folia.ComplexAlignmentLayer) ca = list(l.annotations(folia.ComplexAlignment)) self.assertEqual(len(ca),1) alignments = list(ca[0].select(folia.Alignment)) self.assertEqual(len(alignments),2) def test106_submetadata(self): """Sanity Check - Submetadata""" self.assertEqual(self.doc['WR-P-E-J-0000000001.div0.1'].getmetadata(), self.doc.submetadata['wikipedia.stemma']) self.assertTrue(isinstance(self.doc['WR-P-E-J-0000000001.div0.1'].getmetadata(), folia.NativeMetaData)) self.assertEqual(self.doc.submetadatatype[self.doc['WR-P-E-J-0000000001.div0.1'].metadata], 'native') self.assertEqual(self.doc['WR-P-E-J-0000000001.div0.1'].getmetadata('originalsource'), 'https://nl.wikipedia.org/wiki/Stemma') self.assertEqual(self.doc['WR-P-E-J-0000000001.p.1.s.1.w.1'].getmetadata(), self.doc.submetadata['wikipedia.stemma']) self.assertEqual(self.doc['sandbox.3'].getmetadata(), self.doc.submetadata['sandbox.3.metadata']) self.assertEqual(self.doc['sandbox.3'].getmetadata('author'), 'proycon') self.assertEqual(self.doc['example.table.1.w.1'].getmetadata(), self.doc.submetadata['sandbox.3.metadata']) def test107a_submetadataextref(self): """Sanity Check - Submetadata external reference (CMDI)""" xml = """ """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.submetadatatype['test.metadata'], 'cmdi') self.assertTrue( isinstance(doc['test.text'].getmetadata(), folia.ExternalMetaData) ) self.assertEqual( doc['test.text'].getmetadata().url, 'test.cmdi.xml' ) def test107b_metadatainternal(self): """Sanity Check - Submetadata internal (foreign data) (Dublin Core)""" xml = """ mydoc text/xml Example proycon proycon en Radboud University public Domain """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual( doc.submetadatatype['test.metadata'], 'dc') self.assertTrue( isinstance(doc['test.text'].getmetadata(), folia.ForeignData) ) def test108_text_with_comment(self): """Sanity Check - Text with XML comment""" xml = """\n This is the real text """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual(doc['example.text.1'].text(),"This is the real text") def test108b_text_with_comment(self): """Sanity Check - Text with XML comment""" xml = """\n This is the real text """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual(doc['example.text.1'].text(),"This is the real text") def test108c_text_with_comment(self): """Sanity Check - Text with FoLiA comment""" xml = """\n This is the real textOverbodig """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml) self.assertEqual(doc['example.text.1'].text(),"This is the real text") def test109_precedes(self): """Sanity Check - Check precedes() method""" self.assertTrue( self.doc["WR-P-E-J-0000000001.p.1.s.1.w.1"].precedes(self.doc["WR-P-E-J-0000000001.p.1.s.1.w.2"]) ) self.assertFalse( self.doc["WR-P-E-J-0000000001.p.1.s.1.w.2"].precedes(self.doc["WR-P-E-J-0000000001.p.1.s.1.w.1"]) ) self.assertTrue( self.doc["WR-P-E-J-0000000001.p.1.s.1.w.1"].precedes(self.doc["WR-P-E-J-0000000001.p.1.s.1.w.2"]) ) self.assertTrue( self.doc["WR-P-E-J-0000000001.p.1.s.1.w.1"].precedes(self.doc["WR-P-E-J-0000000001.p.1.s.2.w.9"]) ) self.assertFalse( self.doc["WR-P-E-J-0000000001.p.1.s.2.w.9"].precedes(self.doc["WR-P-E-J-0000000001.p.1.s.1.w.1"]) ) class Test4Edit(unittest.TestCase): def setUp(self): self.doc = folia.Document(string=FOLIAEXAMPLE, textvalidation=True) def test001_addsentence(self): """Edit Check - Adding a sentence to first paragraph (verbose)""" #grab last paragraph p = self.doc.paragraphs(0) #how many sentences? tmp = len(list(p.sentences())) #make a sentence s = folia.Sentence(self.doc, generate_id_in=p) #add words to the sentence s.append( folia.Word(self.doc, text='Dit',generate_id_in=s, annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) s.append( folia.Word(self.doc, text='is',generate_id_in=s, annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) s.append( folia.Word(self.doc, text='een',generate_id_in=s, annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) s.append( folia.Word(self.doc, text='nieuwe',generate_id_in=s, annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) s.append( folia.Word(self.doc, text='zin',generate_id_in=s, annotator='testscript', annotatortype=folia.AnnotatorType.AUTO, space=False ) ) s.append( folia.Word(self.doc, text='.',generate_id_in=s, annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) #add the sentence p.append(s) #ID check self.assertEqual( s[0].id, s.id + '.w.1' ) self.assertEqual( s[1].id, s.id + '.w.2' ) self.assertEqual( s[2].id, s.id + '.w.3' ) self.assertEqual( s[3].id, s.id + '.w.4' ) self.assertEqual( s[4].id, s.id + '.w.5' ) self.assertEqual( s[5].id, s.id + '.w.6' ) #index check self.assertEqual( self.doc[s.id], s ) self.assertEqual( self.doc[s.id + '.w.3'], s[2] ) #attribute check self.assertEqual( s[0].annotator, 'testscript' ) self.assertEqual( s[0].annotatortype, folia.AnnotatorType.AUTO ) #addition to paragraph correct? self.assertEqual( len(list(p.sentences())) , tmp + 1) self.assertEqual( p[-1] , s) # text() ok? self.assertEqual( s.text(), "Dit is een nieuwe zin." ) # xml() ok? self.assertTrue( xmlcheck( s.xmlstring(), 'Ditiseennieuwezin.') ) def test001b_addsentence(self): """Edit Check - Adding a sentence to first paragraph (shortcut)""" #grab last paragraph p = self.doc.paragraphs(0) #how many sentences? tmp = len(list(p.sentences())) s = p.append(folia.Sentence) s.append(folia.Word,'Dit') s.append(folia.Word,'is') s.append(folia.Word,'een') s.append(folia.Word,'nieuwe') w = s.append(folia.Word,'zin') s.append(folia.Word,'.',cls='PUNCTUATION') self.assertEqual( s.id, 'WR-P-E-J-0000000001.p.1.s.9') self.assertEqual( len(list(s.words())), 6 ) #number of words in sentence self.assertEqual( w.text(), 'zin' ) #text check self.assertEqual( self.doc[w.id], w ) #index check #addition to paragraph correct? self.assertEqual( len(list(p.sentences())) , tmp + 1) self.assertEqual( p[-1] , s) self.assertTrue( xmlcheck(s.xmlstring(), 'Ditiseennieuwezin.')) def test001c_addsentence(self): """Edit Check - Adding a sentence to first paragraph (using add instead of append)""" #grab last paragraph p = self.doc.paragraphs(0) #how many sentences? tmp = len(list(p.sentences())) s = p.add(folia.Sentence) s.add(folia.Word,'Dit') s.add(folia.Word,'is') s.add(folia.Word,'een') s.add(folia.Word,'nieuwe') w = s.add(folia.Word,'zin') s.add(folia.Word,'.',cls='PUNCTUATION') self.assertEqual( len(list(s.words())), 6 ) #number of words in sentence self.assertEqual( w.text(), 'zin' ) #text check self.assertEqual( self.doc[w.id], w ) #index check #addition to paragraph correct? self.assertEqual( len(list(p.sentences())) , tmp + 1) self.assertEqual( p[-1] , s) self.assertTrue( xmlcheck(s.xmlstring(), 'Ditiseennieuwezin.')) def test002_addannotation(self): """Edit Check - Adding a token annotation (pos, lemma) (pre-generated instances)""" #grab a word (naam) w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.11'] self.doc.declare(folia.PosAnnotation, 'adhocpos') self.doc.declare(folia.LemmaAnnotation, 'adhoclemma') #add a pos annotation (in a different set than the one already present, to prevent conflict) w.append( folia.PosAnnotation(self.doc, set='adhocpos', cls='NOUN', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) w.append( folia.LemmaAnnotation(self.doc, set='adhoclemma', cls='NAAM', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO, datetime=datetime(1982, 12, 15, 19, 0, 1) ) ) #retrieve and check p = w.annotation(folia.PosAnnotation, 'adhocpos') self.assertTrue( isinstance(p, folia.PosAnnotation) ) self.assertEqual( p.cls, 'NOUN' ) l = w.annotation(folia.LemmaAnnotation, 'adhoclemma') self.assertTrue( isinstance(l, folia.LemmaAnnotation) ) self.assertEqual( l.cls, 'NAAM' ) self.assertTrue( xmlcheck(w.xmlstring(), 'naam') ) def test002b_addannotation(self): """Edit Check - Adding a token annotation (pos, lemma) (instances generated on the fly)""" #grab a word (naam) w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.11'] self.doc.declare(folia.PosAnnotation, 'adhocpos') self.doc.declare(folia.LemmaAnnotation, 'adhoclemma') #add a pos annotation (in a different set than the one already present, to prevent conflict) w.append( folia.PosAnnotation, set='adhocpos', cls='NOUN', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) w.append( folia.LemmaAnnotation, set='adhoclemma', cls='NAAM', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO ) #retrieve and check p = w.annotation(folia.PosAnnotation, 'adhocpos') self.assertTrue( isinstance(p, folia.PosAnnotation) ) self.assertEqual( p.cls, 'NOUN' ) l = w.annotation(folia.LemmaAnnotation, 'adhoclemma') self.assertTrue( isinstance(l, folia.LemmaAnnotation) ) self.assertEqual( l.cls, 'NAAM' ) self.assertTrue( xmlcheck(w.xmlstring(), 'naam')) def test002c_addannotation(self): """Edit Check - Adding a token annotation (pos, lemma) (using add instead of append)""" #grab a word (naam) w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.11'] self.doc.declare(folia.PosAnnotation, 'adhocpos') self.doc.declare(folia.LemmaAnnotation, 'adhoclemma') #add a pos annotation (in a different set than the one already present, to prevent conflict) w.add( folia.PosAnnotation(self.doc, set='adhocpos', cls='NOUN', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) ) w.add( folia.LemmaAnnotation(self.doc, set='adhoclemma', cls='NAAM', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO, datetime=datetime(1982, 12, 15, 19, 0, 1) ) ) #retrieve and check p = w.annotation(folia.PosAnnotation, 'adhocpos') self.assertTrue( isinstance(p, folia.PosAnnotation) ) self.assertEqual( p.cls, 'NOUN' ) l = w.annotation(folia.LemmaAnnotation, 'adhoclemma') self.assertTrue( isinstance(l, folia.LemmaAnnotation) ) self.assertEqual( l.cls, 'NAAM' ) self.assertTrue( xmlcheck(w.xmlstring(), 'naam') ) def test004_addinvalidannotation(self): """Edit Check - Adding a token default-set annotation that clashes with the existing one""" #grab a word (naam) w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.11'] #add a pos annotation without specifying a set (should take default set), but this will clash with existing tag! self.assertRaises( folia.DuplicateAnnotationError, w.append, folia.PosAnnotation(self.doc, cls='N', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO, set="https://raw.githubusercontent.com/proycon/folia/master/setdefinitions/frog-mbpos-cgn" ) ) self.assertRaises( folia.DuplicateAnnotationError, w.append, folia.LemmaAnnotation(self.doc, cls='naam', annotator='testscript', annotatortype=folia.AnnotatorType.AUTO ) ) def test005_addalternative(self): """Edit Check - Adding an alternative token annotation""" w = self.doc['WR-P-E-J-0000000001.p.1.s.2.w.11'] w.append( folia.Alternative(self.doc, generate_id_in=w, contents=folia.PosAnnotation(self.doc, cls='V', set="https://raw.githubusercontent.com/proycon/folia/master/setdefinitions/frog-mbpos-cgn" ))) #reobtaining it: alt = list(w.alternatives()) #all alternatives set = "https://raw.githubusercontent.com/proycon/folia/master/setdefinitions/frog-mbpos-cgn" #pylint: disable=redefined-builtin alt2 = list(w.alternatives(folia.PosAnnotation, set)) self.assertEqual( alt[0],alt2[0] ) self.assertEqual( len(alt),1 ) self.assertEqual( len(alt2),1 ) self.assertTrue( isinstance(alt[0].annotation(folia.PosAnnotation, set), folia.PosAnnotation) ) self.assertTrue( xmlcheck(w.xmlstring(), 'naam')) def test006_addcorrection(self): """Edit Check - Correcting Text""" w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn w.correct(new='stippellijn', set='corrections',cls='spelling',annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) self.assertEqual( w.annotation(folia.Correction).original(0).text() ,'stippelijn' ) self.assertEqual( w.annotation(folia.Correction).new(0).text() ,'stippellijn' ) self.assertEqual( w.text(), 'stippellijn') self.assertTrue( xmlcheck(w.xmlstring(),'stippellijnstippelijn')) def test006b_addcorrection(self): """Edit Check - Correcting Text (2)""" w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn w.correct(new=folia.TextContent(self.doc,value='stippellijn',set='undefined',cls='current'), set='corrections',cls='spelling',annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) self.assertEqual( w.annotation(folia.Correction).original(0).text() ,'stippelijn' ) self.assertEqual( w.annotation(folia.Correction).new(0).text() ,'stippellijn' ) self.assertEqual( w.text(), 'stippellijn') self.assertTrue( xmlcheck(w.xmlstring(),'stippellijnstippelijn')) def test007_addcorrection2(self): """Edit Check - Correcting a Token Annotation element""" w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn oldpos = w.annotation(folia.PosAnnotation) newpos = folia.PosAnnotation(self.doc, cls='N(soort,ev,basis,zijd,stan)', set="https://raw.githubusercontent.com/proycon/folia/master/setdefinitions/frog-mbpos-cgn" ) w.correct(original=oldpos,new=newpos, set='corrections',cls='spelling',annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) self.assertEqual( w.annotation(folia.Correction).original(0) ,oldpos ) self.assertEqual( w.annotation(folia.Correction).new(0),newpos ) self.assertTrue( xmlcheck(w.xmlstring(),'stippelijn')) def test008_addsuggestion(self): """Edit Check - Suggesting a text correction""" w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn w.correct(suggestion='stippellijn', set='corrections',cls='spelling',annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) self.assertTrue( isinstance(w.annotation(folia.Correction), folia.Correction) ) self.assertEqual( w.annotation(folia.Correction).suggestions(0).text() , 'stippellijn' ) self.assertEqual( w.text(), 'stippelijn') self.assertTrue( xmlcheck(w.xmlstring(),'stippelijnstippellijn')) def test009a_idclash(self): """Edit Check - Checking for exception on adding a duplicate ID""" w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] self.assertRaises( folia.DuplicateIDError, w.sentence().append, folia.Word, id='WR-P-E-J-0000000001.p.1.s.8.w.11', text='stippellijn') #def test009b_textcorrectionlevel(self): # """Edit Check - Checking for exception on an adding TextContent of wrong level""" # w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] # # self.assertRaises( ValueError, w.append, folia.TextContent, value='blah', corrected=folia.TextCorrectionLevel.ORIGINAL ) # #def test009c_duptextcontent(self): # """Edit Check - Checking for exception on an adding duplicate textcontent""" # w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] # # self.assertRaises( folia.DuplicateAnnotationError, w.append, folia.TextContent, value='blah', corrected=folia.TextCorrectionLevel.PROCESSED ) def test010_documentlesselement(self): """Edit Check - Creating an initially document-less tokenannotation element and adding it to a word""" #not associated with any document yet (first argument is None instead of Document instance) pos = folia.PosAnnotation(None, set='fakecgn', cls='N') w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] w.append(pos) self.assertEqual( w.annotation(folia.PosAnnotation,'fakecgn'), pos) self.assertEqual( pos.parent, w) self.assertEqual( pos.doc, w.doc) self.assertTrue( xmlcheck(w.xmlstring(), 'stippelijn')) def test011_subtokenannot(self): """Edit Check - Adding morphemes""" w = self.doc['WR-P-E-J-0000000001.p.1.s.5.w.3'] l = w.append( folia.MorphologyLayer ) l.append( folia.Morpheme(self.doc, folia.TextContent(self.doc, value='handschrift', offset=0), folia.LemmaAnnotation(self.doc, cls='handschrift'), cls='stem',function='lexical' )) l.append( folia.Morpheme(self.doc, folia.TextContent(self.doc, value='en', offset=11), cls='suffix',function='inflexional' )) self.assertEqual( len(l), 2) #two morphemes self.assertTrue( isinstance(l[0], folia.Morpheme ) ) self.assertEqual( l[0].text(), 'handschrift' ) self.assertEqual( l[0].cls , 'stem' ) self.assertEqual( l[0].feat('function'), 'lexical' ) self.assertEqual( l[1].text(), 'en' ) self.assertEqual( l[1].cls, 'suffix' ) self.assertEqual( l[1].feat('function'), 'inflexional' ) self.assertTrue( xmlcheck(w.xmlstring(),'handschriftenhandschriften')) def test012_alignment(self): """Edit Check - Adding Alignment""" w = self.doc['WR-P-E-J-0000000001.p.1.s.6.w.8'] a = w.append( folia.Alignment, cls="coreference") a.append( folia.AlignReference, id='WR-P-E-J-0000000001.p.1.s.6.w.1', type=folia.Word) a.append( folia.AlignReference, id='WR-P-E-J-0000000001.p.1.s.6.w.2', type=folia.Word) self.assertEqual( next(a.resolve()), self.doc['WR-P-E-J-0000000001.p.1.s.6.w.1'] ) self.assertEqual( list(a.resolve())[1], self.doc['WR-P-E-J-0000000001.p.1.s.6.w.2'] ) self.assertTrue( xmlcheck(w.xmlstring(),'ze')) def test013_spanannot(self): """Edit Check - Adding nested Span Annotatation (syntax)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.4'] #sentence: 'De hoofdletter A wordt gebruikt voor het originele handschrift .' layer = s.append(folia.SyntaxLayer) layer.append( folia.SyntacticUnit(self.doc,cls='s',contents=[ folia.SyntacticUnit(self.doc,cls='np', contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.1'] ,cls='det'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.2'], cls='n'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.3'], cls='n'), ]), folia.SyntacticUnit(self.doc,cls='vp',contents=[ folia.SyntacticUnit(self.doc,cls='vp',contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.4'], cls='v'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.5'], cls='participle'), ]), folia.SyntacticUnit(self.doc, cls='pp',contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.6'], cls='prep'), folia.SyntacticUnit(self.doc, cls='np',contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.7'], cls='det'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.8'], cls='adj'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.9'], cls='n'), ]) ]) ]) ]) ) self.assertTrue( xmlcheck(layer.xmlstring(),'')) def test013a_spanannot(self): """Edit Check - Adding Span Annotation (entity, from word using add)""" word = self.doc["WR-P-E-J-0000000001.p.1.s.4.w.2"] #hoofdletter word2 = self.doc["WR-P-E-J-0000000001.p.1.s.4.w.3"] #A entity = word.add(folia.Entity, word, word2, cls="misc",set="http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml") self.assertIsInstance(entity, folia.Entity) self.assertTrue(xmlcheck(entity.parent.parent.xmlstring(),'DeDehoofdletterhoofdletterAA')) def test013b_spanannot(self): """Edit Check - Adding nested Span Annotatation (add as append)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.4'] #sentence: 'De hoofdletter A wordt gebruikt voor het originele handschrift .' layer = s.add(folia.SyntaxLayer) layer.add( folia.SyntacticUnit(self.doc,cls='s',contents=[ folia.SyntacticUnit(self.doc,cls='np', contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.1'] ,cls='det'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.2'], cls='n'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.3'], cls='n'), ]), folia.SyntacticUnit(self.doc,cls='vp',contents=[ folia.SyntacticUnit(self.doc,cls='vp',contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.4'], cls='v'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.5'], cls='participle'), ]), folia.SyntacticUnit(self.doc, cls='pp',contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.6'], cls='prep'), folia.SyntacticUnit(self.doc, cls='np',contents=[ folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.7'], cls='det'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.8'], cls='adj'), folia.SyntacticUnit(self.doc, self.doc['WR-P-E-J-0000000001.p.1.s.4.w.9'], cls='n'), ]) ]) ]) ]) ) self.assertTrue( xmlcheck(layer.xmlstring(),'')) def test013c_spanannotcorrection(self): """Edit Check - Correcting Span Annotation""" s = self.doc['example.cell'] l = s.annotation(folia.EntitiesLayer) l.correct(original=self.doc['example.radboud.university.nijmegen.org'], new=folia.Entity(self.doc, *self.doc['example.radboud.university.nijmegen.org'].wrefs(), cls="loc",set="http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml") ,set='corrections',cls='wrongclass') self.assertTrue( xmlcheck(l.xmlstring(), 'This is our university!')) def test013d_spanannot(self): """Edit Check - Adding Span Annotation (entity, from sentence using add)""" sentence = self.doc["WR-P-E-J-0000000001.p.1.s.4"] word = self.doc["WR-P-E-J-0000000001.p.1.s.4.w.2"] #hoofdletter word2 = self.doc["WR-P-E-J-0000000001.p.1.s.4.w.3"] #A entity = sentence.add(folia.Entity, word, word2, cls="misc",set="http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml") self.assertIsInstance(entity, folia.Entity) self.assertTrue(xmlcheck(entity.parent.parent.xmlstring(),'De hoofdletter A wordt gebruikt voor het originele handschrift.De hoofdletter A wordt gebruikt voor het originele handschrift.Uppercase A is used for the original.DeDehoofdletterhoofdletterAAwordtwordtgebruiktgebruiktvoorvoorhethetorigineleoriginelehandschrifthandschrift..')) def test013e_spanannot(self): """Edit Check - Adding nested Span Annotation""" word = self.doc["WR-P-E-J-0000000001.p.1.s.1.w.7"] #stamboom for su in word.findspans(folia.SyntacticUnit): if su.cls == 'pp': parentspan = su self.assertIsInstance(parentspan, folia.SyntacticUnit) self.assertEqual(parentspan.wrefs(recurse=False) , [self.doc["WR-P-E-J-0000000001.p.1.s.1.w.6"],self.doc["WR-P-E-J-0000000001.p.1.s.1.w.7"]]) #prior to adding newspan = parentspan.add(folia.SyntacticUnit, word, cls='np') self.assertEqual(parentspan.wrefs(recurse=False) , [self.doc["WR-P-E-J-0000000001.p.1.s.1.w.6"]]) #after adding, parent span wref gone (moved to child) self.assertEqual(parentspan.wrefs(recurse=True) , [self.doc["WR-P-E-J-0000000001.p.1.s.1.w.6"],self.doc["WR-P-E-J-0000000001.p.1.s.1.w.7"]]) #result is still the same with recursion self.assertEqual(newspan.wrefs() , [self.doc["WR-P-E-J-0000000001.p.1.s.1.w.7"]]) def test014_replace(self): """Edit Check - Replacing an annotation""" word = self.doc['WR-P-E-J-0000000001.p.1.s.3.w.14'] word.replace(folia.PosAnnotation(self.doc, cls='BOGUS', set="https://raw.githubusercontent.com/proycon/folia/master/setdefinitions/frog-mbpos-cgn" ) ) self.assertEqual( len(list(word.annotations(folia.PosAnnotation))), 1) self.assertEqual( word.annotation(folia.PosAnnotation).cls, 'BOGUS') self.assertTrue( xmlcheck(word.xmlstring(), 'plaats')) def test015_remove(self): """Edit Check - Removing an annotation""" word = self.doc['WR-P-E-J-0000000001.p.1.s.3.w.14'] word.remove( word.annotation(folia.PosAnnotation) ) self.assertRaises( folia.NoSuchAnnotation, word.annotation, folia.PosAnnotation ) self.assertTrue( xmlcheck(word.xmlstring(), 'plaats')) def test016_datetime(self): """Edit Check - Time stamp""" w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.16'] pos = w.annotation(folia.PosAnnotation) pos.datetime = datetime(1982, 12, 15, 19, 0, 1) #(the datetime of my joyful birth) self.assertTrue( xmlcheck(pos.xmlstring(), '')) def test017_wordtext(self): """Edit Check - Altering word text""" #Important note: directly altering text is usually bad practise, you'll want to use proper corrections instead. #this may also lead to inconsistencies if there is redundant text on higher levels w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.9'] self.assertEqual(w.text(), 'terweil') w.settext('terwijl') self.assertEqual(w.text(), 'terwijl') def test017b_wordtext(self): """Edit Check - Altering word text with reserved symbols""" #Important note: directly altering text is usually bad practise, you'll want to use proper corrections instead. #This test just serves to test reserved symbols w = self.doc['WR-P-E-J-0000000001.p.1.s.8.w.9'] w.settext('1 & 1 > 0') self.assertEqual(w.text(), '1 & 1 > 0') self.assertEqual(w.textcontent().xmlstring(), '1 & 1 > 0') def test018a_sentencetext(self): """Edit Check - Altering sentence text (untokenised by definition)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.1'] self.assertEqual(s.text(), 'Stemma is een ander woord voor stamboom.') #text is obtained from children, since there is no direct text associated self.assertFalse(s.hastext()) #no text DIRECTLY associated with the sentence #associating text directly with the sentence (should be in agreement with text from children) s.settext('Stemma is een ander woord voor stamboom.') self.assertTrue(s.hastext()) self.assertEqual(s.text(), 'Stemma is een ander woord voor stamboom.') #text still obtained from children rather than directly associated text!! self.assertEqual(s.stricttext(), 'Stemma is een ander woord voor stamboom.') #text obtained directly def test018b_sentencetext(self): """Edit Check - Altering sentence text (untokenised by definition)""" s = self.doc['WR-P-E-J-0000000001.p.1.s.8'] self.assertEqual( s.text(), 'Een volle lijn duidt op een verwantschap , terweil een stippelijn op een onzekere verwantschap duidt .' ) #dynamic from children #s.settext('Een volle lijn duidt op een verwantschap, terwijl een stippellijn op een onzekere verwantschap duidt.' ) #setting the correct text here will cause a mismatch with the text on deeper levels, but is permitted (deep validation should detect it) s.settext('Een volle lijn duidt op een verwantschap, terweil een stippelijn op een onzekere verwantschap duidt.', 'original' ) self.assertEqual( s.text(), 'Een volle lijn duidt op een verwantschap , terweil een stippelijn op een onzekere verwantschap duidt .' ) #from children by default (child has erroneous stippelijn and terweil) self.assertTrue( s.hastext('original') ) self.assertEqual( s.stricttext('original'), 'Een volle lijn duidt op een verwantschap, terweil een stippelijn op een onzekere verwantschap duidt.' ) self.assertTrue( xmlcheck(s.xmlstring(), 'Een volle lijn duidt op een verwantschap, terweil een stippelijn op een onzekere verwantschap duidt.Eenvollelijnduidtopeenverwantschap,terweileenstippelijnopeenonzekeretwijfelachtigeongewisseverwantschapduidt.Confusion between EI and IJ diphtongues')) def test019_adderrordetection(self): """Edit Check - Error Detection""" w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn w.append( folia.ErrorDetection(self.doc, cls="spelling", annotator="testscript", annotatortype=folia.AnnotatorType.AUTO) ) self.assertEqual( w.annotation(folia.ErrorDetection).cls ,'spelling' ) #self.assertTrue( xmlcheck(w.xmlstring(),'stippellijnstippelijn')) #def test008_addaltcorrection(self): # """Edit Check - Adding alternative corrections""" # w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn # w.correcttext('stippellijn', set='corrections',cls='spelling',annotator='testscript', annotatortype='auto', alternative=True) # # alt = w.alternatives(folia.AnnotationType.CORRECTION) # self.assertEqual( alt[0].annotation(folia.Correction).original[0] ,'stippelijn' ) # self.assertEqual( alt[0].annotation(folia.Correction).new[0] ,'stippellijn' ) #def test009_addaltcorrection2(self): # """Edit Check - Adding an alternative and a selected correction""" # w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn # w.correcttext('stippel-lijn', set='corrections',cls='spelling',annotator='testscript', annotatortype='auto', alternative=True) # w.correcttext('stippellijn', set='corrections',cls='spelling',annotator='testscript', annotatortype='auto') # alt = w.alternatives(folia.AnnotationType.CORRECTION) # self.assertEqual( alt[0].annotation(folia.Correction).id ,'WR-P-E-J-0000000001.p.1.s.8.w.11.correction.1' ) # self.assertEqual( alt[0].annotation(folia.Correction).original[0] ,'stippelijn' ) # self.assertEqual( alt[0].annotation(folia.Correction).new[0] ,'stippel-lijn' ) # self.assertEqual( w.annotation(folia.Correction).id ,'WR-P-E-J-0000000001.p.1.s.8.w.11.correction.2' ) # self.assertEqual( w.annotation(folia.Correction).original[0] ,'stippelijn' ) # self.assertEqual( w.annotation(folia.Correction).new[0] ,'stippellijn' ) # self.assertEqual( w.text(), 'stippellijn') class Test4Create(unittest.TestCase): def test001_create(self): """Creating a FoLiA Document from scratch""" self.doc = folia.Document(id='example') self.doc.declare(folia.AnnotationType.TOKEN, 'adhocset',annotator='proycon') self.assertEqual(self.doc.defaultset(folia.AnnotationType.TOKEN), 'adhocset') self.assertEqual(self.doc.defaultannotator(folia.AnnotationType.TOKEN, 'adhocset'), 'proycon') text = folia.Text(self.doc, id=self.doc.id + '.text.1') self.doc.append( text ) text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="De"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="site"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="staat"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="online"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text=".") ]) ) self.assertEqual( len(self.doc.index[self.doc.id + '.s.1']), 5) class Test5Correction(unittest.TestCase): def setUp(self): self.doc = folia.Document(id='example', textvalidation=True) self.doc.declare(folia.AnnotationType.TOKEN, set='adhocset',annotator='proycon') self.text = folia.Text(self.doc, id=self.doc.id + '.text.1') self.doc.append( self.text ) def test001_splitcorrection(self): """Correction - Split correction""" self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="De"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="site"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="staat"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="online"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text=".") ]) ) w = self.doc.index[self.doc.id + '.s.1.w.4'] w.split( folia.Word(self.doc, id=self.doc.id + '.s.1.w.4a', text="on"), folia.Word(self.doc, id=self.doc.id + '.s.1.w.4b', text="line") ) s = self.doc.index[self.doc.id + '.s.1'] self.assertEqual( s.words(-3).text(), 'on' ) self.assertEqual( s.words(-2).text(), 'line' ) self.assertEqual( s.text(), 'De site staat on line .' ) self.assertEqual( len(list(s.words())), 6 ) self.assertTrue( xmlcheck(s.xmlstring(), 'Desitestaatonlineonline.')) def test001_splitcorrection2(self): """Correction - Split suggestion""" self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="De"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="site"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="staat"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="online"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text=".") ]) ) w = self.doc.index[self.doc.id + '.s.1.w.4'] s = self.doc.index[self.doc.id + '.s.1'] w.split( folia.Word(self.doc, generate_id_in=s, text="on"), folia.Word(self.doc, generate_id_in=s, text="line"), suggest=True ) self.assertEqual( len(list(s.words())), 5 ) self.assertEqual( s.words(-2).text(), 'online' ) self.assertEqual( s.text(), 'De site staat online .' ) self.assertTrue( xmlcheck(s.xmlstring(), 'Desitestaatonlineonline.')) def test002_mergecorrection(self): """Correction - Merge corrections""" self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="De"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="site"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="staat"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="on"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text="line"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.6', text=".") ]) ) s = self.doc.index[self.doc.id + '.s.1'] s.mergewords( folia.Word(self.doc, 'online', id=self.doc.id + '.s.1.w.4-5') , self.doc.index[self.doc.id + '.s.1.w.4'], self.doc.index[self.doc.id + '.s.1.w.5'] ) self.assertEqual( len(list(s.words())), 5 ) self.assertEqual( s.text(), 'De site staat online .') #incorrection() test, check if newly added word correctly reports being part of a correction w = self.doc.index[self.doc.id + '.s.1.w.4-5'] self.assertTrue( isinstance(w.incorrection(), folia.Correction) ) #incorrection return the correction the word is part of, or None if not part of a correction, self.assertTrue( xmlcheck(s.xmlstring(), 'Desitestaatonlineonline.')) def test003_deletecorrection(self): """Correction - Deletion""" self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="Ik"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="zie"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="een"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="groot"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text="huis"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.6', text=".") ]) ) s = self.doc.index[self.doc.id + '.s.1'] s.deleteword(self.doc.index[self.doc.id + '.s.1.w.4']) self.assertEqual( len(list(s.words())), 5 ) self.assertEqual( s.text(), 'Ik zie een huis .') self.assertTrue( xmlcheck(s.xmlstring(), 'Ikzieeengroothuis.') ) def test004_insertcorrection(self): """Correction - Insert""" self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="Ik"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="zie"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="een"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="huis"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text=".") ]) ) s = self.doc.index[self.doc.id + '.s.1'] s.insertword( folia.Word(self.doc, id=self.doc.id+'.s.1.w.3b',text='groot'), self.doc.index[self.doc.id + '.s.1.w.3']) self.assertEqual( len(list(s.words())), 6 ) self.assertEqual( s.text(), 'Ik zie een groot huis .') self.assertTrue( xmlcheck( s.xmlstring(), 'Ikzieeengroothuis.')) def test005_reusecorrection(self): """Correction - Re-using a correction with only suggestions""" self.doc = folia.Document(string=FOLIAEXAMPLE) w = self.doc.index['WR-P-E-J-0000000001.p.1.s.8.w.11'] #stippelijn w.correct(suggestion='stippellijn', set='corrections',cls='spelling',annotator='testscript', annotatortype=folia.AnnotatorType.AUTO) c = w.annotation(folia.Correction) self.assertTrue( isinstance(w.annotation(folia.Correction), folia.Correction) ) self.assertEqual( w.annotation(folia.Correction).suggestions(0).text() , 'stippellijn' ) self.assertEqual( w.text(), 'stippelijn') w.correct(new='stippellijn',set='corrections',cls='spelling',annotator='John Doe', annotatortype=folia.AnnotatorType.MANUAL,reuse=c.id) self.assertEqual( w.text(), 'stippellijn') self.assertEqual( len(list(w.annotations(folia.Correction))), 1 ) self.assertEqual( w.annotation(folia.Correction).suggestions(0).text() , 'stippellijn' ) self.assertEqual( w.annotation(folia.Correction).suggestions(0).annotator , 'testscript' ) self.assertEqual( w.annotation(folia.Correction).suggestions(0).annotatortype , folia.AnnotatorType.AUTO) self.assertEqual( w.annotation(folia.Correction).new(0).text() , 'stippellijn' ) self.assertEqual( w.annotation(folia.Correction).annotator , 'John Doe' ) self.assertEqual( w.annotation(folia.Correction).annotatortype , folia.AnnotatorType.MANUAL) self.assertTrue( xmlcheck(w.xmlstring(), 'stippellijnstippellijnstippelijn')) def test006_deletionsuggestion(self): """Correction - Suggestion for deletion with parent merge suggestion""" self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.1', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.1.w.1', text="De"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.2', text="site"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.3', text="staat"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.4', text="on"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.5', text="line"), folia.Word(self.doc,id=self.doc.id + '.s.1.w.6', text=".") ]), ) self.text.append( folia.Sentence(self.doc,id=self.doc.id + '.s.2', contents=[ folia.Word(self.doc,id=self.doc.id + '.s.2.w.1', text="sinds"), folia.Word(self.doc,id=self.doc.id + '.s.2.w.2', text="vorige"), folia.Word(self.doc,id=self.doc.id + '.s.2.w.3', text="week"), folia.Word(self.doc,id=self.doc.id + '.s.2.w.4', text="zondag"), folia.Word(self.doc,id=self.doc.id + '.s.2.w.6', text=".") ]) ) s = self.doc.index[self.doc.id + '.s.1'] s2 = self.doc.index[self.doc.id + '.s.2'] w = self.doc.index[self.doc.id + '.s.1.w.6'] s.remove(w) s.append( folia.Correction(self.doc, folia.Current(self.doc, w), folia.Suggestion(self.doc, merge=s2.id)) ) self.assertTrue( xmlcheck(s.xmlstring(), 'Desitestaatonline.')) class Test6Query(unittest.TestCase): def setUp(self): self.doc = folia.Document(string=FOLIAEXAMPLE, textvalidation=True) def test001_findwords_simple(self): """Querying - Find words (simple)""" matches = list(self.doc.findwords( folia.Pattern('van','het','alfabet') )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 3 ) self.assertEqual( matches[0][0].text(), 'van' ) self.assertEqual( matches[0][1].text(), 'het' ) self.assertEqual( matches[0][2].text(), 'alfabet' ) def test002_findwords_wildcard(self): """Querying - Find words (with wildcard)""" matches = list(self.doc.findwords( folia.Pattern('van','het',True) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 3 ) self.assertEqual( matches[0][0].text(), 'van' ) self.assertEqual( matches[0][1].text(), 'het' ) self.assertEqual( matches[0][2].text(), 'alfabet' ) def test003_findwords_annotation(self): """Querying - Find words by annotation""" matches = list(self.doc.findwords( folia.Pattern('de','historisch','wetenschap','worden', matchannotation=folia.LemmaAnnotation) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 4 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'historische' ) self.assertEqual( matches[0][2].text(), 'wetenschap' ) self.assertEqual( matches[0][3].text(), 'wordt' ) def test004_findwords_multi(self): """Querying - Find words using a conjunction of multiple patterns """ matches = list(self.doc.findwords( folia.Pattern('de','historische',True, 'wordt'), folia.Pattern('de','historisch','wetenschap','worden', matchannotation=folia.LemmaAnnotation) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 4 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'historische' ) self.assertEqual( matches[0][2].text(), 'wetenschap' ) self.assertEqual( matches[0][3].text(), 'wordt' ) def test005_findwords_none(self): """Querying - Find words that don't exist""" matches = list(self.doc.findwords( folia.Pattern('bli','bla','blu'))) self.assertEqual( len(matches), 0) def test006_findwords_overlap(self): """Querying - Find words with overlap""" doc = folia.Document(id='test') text = folia.Text(doc, id='test.text') text.append( folia.Sentence(doc,id=doc.id + '.s.1', contents=[ folia.Word(doc,id=doc.id + '.s.1.w.1', text="a"), folia.Word(doc,id=doc.id + '.s.1.w.2', text="a"), folia.Word(doc,id=doc.id + '.s.1.w.3', text="a"), folia.Word(doc,id=doc.id + '.s.1.w.4', text="A"), folia.Word(doc,id=doc.id + '.s.1.w.5', text="b"), folia.Word(doc,id=doc.id + '.s.1.w.6', text="a"), folia.Word(doc,id=doc.id + '.s.1.w.7', text="a"), ]) ) doc.append(text) matches = list(doc.findwords( folia.Pattern('a','a'))) self.assertEqual( len(matches), 4) matches = list(doc.findwords( folia.Pattern('a','a',casesensitive=True))) self.assertEqual( len(matches), 3) def test007_findwords_context(self): """Querying - Find words with context""" matches = list(self.doc.findwords( folia.Pattern('van','het','alfabet'), leftcontext=3, rightcontext=3 )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 9 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'laatste' ) self.assertEqual( matches[0][2].text(), 'letters' ) self.assertEqual( matches[0][3].text(), 'van' ) self.assertEqual( matches[0][4].text(), 'het' ) self.assertEqual( matches[0][5].text(), 'alfabet' ) self.assertEqual( matches[0][6].text(), 'en' ) self.assertEqual( matches[0][7].text(), 'worden' ) self.assertEqual( matches[0][8].text(), 'tussen' ) def test008_findwords_disjunction(self): """Querying - Find words with disjunctions""" matches = list(self.doc.findwords( folia.Pattern('de',('historische','hedendaagse'),'wetenschap','wordt') )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 4 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'historische' ) self.assertEqual( matches[0][2].text(), 'wetenschap' ) self.assertEqual( matches[0][3].text(), 'wordt' ) def test009_findwords_regexp(self): """Querying - Find words with regular expressions""" matches = list(self.doc.findwords( folia.Pattern('de',folia.RegExp('hist.*'),folia.RegExp('.*schap'),folia.RegExp('w[oae]rdt')) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 4 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'historische' ) self.assertEqual( matches[0][2].text(), 'wetenschap' ) self.assertEqual( matches[0][3].text(), 'wordt' ) def test010a_findwords_variablewildcard(self): """Querying - Find words with variable wildcard""" matches = list(self.doc.findwords( folia.Pattern('de','laatste','*','alfabet') )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 6 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'laatste' ) self.assertEqual( matches[0][2].text(), 'letters' ) self.assertEqual( matches[0][3].text(), 'van' ) self.assertEqual( matches[0][4].text(), 'het' ) self.assertEqual( matches[0][5].text(), 'alfabet' ) def test010b_findwords_varwildoverlap(self): """Querying - Find words with variable wildcard and overlap""" doc = folia.Document(id='test') text = folia.Text(doc, id='test.text') text.append( folia.Sentence(doc,id=doc.id + '.s.1', contents=[ folia.Word(doc,id=doc.id + '.s.1.w.1', text="a"), folia.Word(doc,id=doc.id + '.s.1.w.2', text="b"), folia.Word(doc,id=doc.id + '.s.1.w.3', text="c"), folia.Word(doc,id=doc.id + '.s.1.w.4', text="d"), folia.Word(doc,id=doc.id + '.s.1.w.5', text="a"), folia.Word(doc,id=doc.id + '.s.1.w.6', text="b"), folia.Word(doc,id=doc.id + '.s.1.w.7', text="c"), ]) ) doc.append(text) matches = list(doc.findwords( folia.Pattern('a','*', 'c'))) self.assertEqual( len(matches), 3) def test011_findwords_annotation_na(self): """Querying - Find words by non existing annotation""" matches = list(self.doc.findwords( folia.Pattern('bli','bla','blu', matchannotation=folia.SenseAnnotation) )) self.assertEqual( len(matches), 0 ) class Test9Reader(unittest.TestCase): def setUp(self): self.reader = folia.Reader(os.path.join(TMPDIR,"foliatest.xml"), folia.Word) def test000_worditer(self): """Stream reader - Iterating over words""" count = 0 for _ in self.reader: count += 1 self.assertEqual(count, 192) def test001_findwords_simple(self): """Querying using stream reader - Find words (simple)""" matches = list(self.reader.findwords( folia.Pattern('van','het','alfabet') )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 3 ) self.assertEqual( matches[0][0].text(), 'van' ) self.assertEqual( matches[0][1].text(), 'het' ) self.assertEqual( matches[0][2].text(), 'alfabet' ) def test002_findwords_wildcard(self): """Querying using stream reader - Find words (with wildcard)""" matches = list(self.reader.findwords( folia.Pattern('van','het',True) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 3 ) self.assertEqual( matches[0][0].text(), 'van' ) self.assertEqual( matches[0][1].text(), 'het' ) self.assertEqual( matches[0][2].text(), 'alfabet' ) def test003_findwords_annotation(self): """Querying using stream reader - Find words by annotation""" matches = list(self.reader.findwords( folia.Pattern('de','historisch','wetenschap','worden', matchannotation=folia.LemmaAnnotation) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 4 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'historische' ) self.assertEqual( matches[0][2].text(), 'wetenschap' ) self.assertEqual( matches[0][3].text(), 'wordt' ) def test004_findwords_multi(self): """Querying using stream reader - Find words using a conjunction of multiple patterns """ matches = list(self.reader.findwords( folia.Pattern('de','historische',True, 'wordt'), folia.Pattern('de','historisch','wetenschap','worden', matchannotation=folia.LemmaAnnotation) )) self.assertEqual( len(matches), 1 ) self.assertEqual( len(matches[0]), 4 ) self.assertEqual( matches[0][0].text(), 'de' ) self.assertEqual( matches[0][1].text(), 'historische' ) self.assertEqual( matches[0][2].text(), 'wetenschap' ) self.assertEqual( matches[0][3].text(), 'wordt' ) def test005_findwords_none(self): """Querying using stream reader - Find words that don't exist""" matches = list(self.reader.findwords( folia.Pattern('bli','bla','blu'))) self.assertEqual( len(matches), 0) def test011_findwords_annotation_na(self): """Querying using stream reader - Find words by non existing annotation""" matches = list(self.reader.findwords( folia.Pattern('bli','bla','blu', matchannotation=folia.SenseAnnotation) )) self.assertEqual( len(matches), 0 ) class Test7XpathQuery(unittest.TestCase): def test050_findwords_xpath(self): """Xpath Querying - Collect all words (including non-authoritative)""" count = 0 for word in folia.Query(os.path.join(TMPDIR,'foliatest.xml'),'//f:w'): count += 1 self.assertTrue( isinstance(word, folia.Word) ) self.assertEqual(count, 192) def test051_findwords_xpath(self): """Xpath Querying - Collect all words (authoritative only)""" count = 0 for word in folia.Query(os.path.join(TMPDIR,'foliatest.xml'),'//f:w[not(ancestor-or-self::*/@auth)]'): count += 1 self.assertTrue( isinstance(word, folia.Word) ) self.assertEqual(count, 190) class Test8Validation(unittest.TestCase): def test000_relaxng(self): """Validation - RelaxNG schema generation""" folia.relaxng() def test001_shallowvalidation(self): """Validation - Shallow validation against automatically generated RelaxNG schema""" folia.validate(os.path.join(TMPDIR,'foliasavetest.xml')) def test002_loadsetdefinitions(self): """Validation - Loading of set definitions""" doc = folia.Document(file=os.path.join(TMPDIR,'foliatest.xml'), loadsetdefinitions=True) assert isinstance( doc.setdefinitions["http://raw.github.com/proycon/folia/master/setdefinitions/namedentities.foliaset.xml"], folia.SetDefinition) class Test9Validation(unittest.TestCase): def test001_deepvalidation(self): """Validation - Deep Validation""" folia.Document(file=os.path.join(FOLIAPATH,'test/example.deep.xml'), deepvalidation=True, textvalidation=True, allowadhocsets=True) def test002_textvalidation(self): """Validation - Text Validation""" folia.Document(file=os.path.join(FOLIAPATH,'test/example.textvalidation.xml'), textvalidation=True) def test003_invalid_text_misspelled(self): """Validation - Invalid Text (Misspelled word)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig literrair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) self.assertRaises( folia.InconsistentText, folia.Document, string=xml, textvalidation=True) #exception def test004_invalid_text_missing(self): """Validation - Invalid Text (Missing Word)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) self.assertRaises( folia.InconsistentText, folia.Document, string=xml, textvalidation=True) #exception def test005_textvalidation_intermittent_redundancy(self): """Validation - Text Validation (Intermittent Redundancy)""" xml = """ Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Of kan ik het ook?

Is het creëren van een volwaardig oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Of kan ik het ook ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) folia.Document(file=os.path.join(FOLIAPATH,'test/example.textvalidation.xml'), textvalidation=True) def test006_multiple_textclasses(self): """Validation - Invalid Text (Multiple classes)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) folia.Document(string=xml, textvalidation=True) def test007_textcheck_no_morphemes(self): """Validation - No text checking on (nested) morphemes""" xml = """ genealogie genealogie genealogisch ie """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) folia.Document(string=xml, textvalidation=True) def test008_offset(self): """Validation - Offset validation""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus , Haasse , of Grunberg ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) self.assertEqual( doc['example.p.1.s.1.w.19'].textcontent().getreference(), doc['example.p.1.s.1'] ) #testing resolving implicit reference def test009_invalid_offset(self): """Validation - Offset validation (invalid)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus , Haasse , of Grunberg ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) self.assertRaises( folia.UnresolvableTextContent, folia.Document, string=xml, textvalidation=True) #exception def test010_offset_reference(self): """Validation - Offset validation with explicit references""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus, Haasse, of Grunberg? Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus , Haasse , of Grunberg ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) self.assertEqual( doc['example.p.1.s.1.w.19'].textcontent().getreference(), doc['example.p.1'] ) #testing resolving explicit reference def test011a_offset_textmarkup(self): """Validation - Offset validation with text markup (non-text-modifiers)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers \tals Couperus, Haasse, of \tGrunberg? Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus , Haasse , of Grunberg ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) self.assertEqual( doc['example.p.1.s.1.w.19'].textcontent().getreference(), doc['example.p.1.s.1'] ) #testing resolving implicit reference def test011b_offset_textmarkup(self): """Validation - Offset validation with text markup (with text modifiers like br)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers
\tals Couperus, Haasse, of \tGrunberg? Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers als Couperus , Haasse , of Grunberg ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) self.assertEqual( doc['example.p.1.s.1.w.19'].textcontent().getreference(), doc['example.p.1.s.1'] ) #testing resolving implicit reference def test012_string(self): """Validation - Text Validation on String""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers
\tals Couperus, Haasse, of \tGrunberg? creëren

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) self.assertEqual( doc['example.string'].textcontent().getreference(), doc['example.p.1.s.1'] ) #testing resolving implicit reference def test013a_correction(self): """Validation - Text Validation on Correction (single text layer)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers? Is het creëren creeren van een volwaardig literair oeuvre voorbehouden aan schrijvers ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) def test013b_correction(self): """Validation - Text Validation on Correction (Double text layers)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers? Is het creeren van een volwaardig litterair oeuvre voorbehouden aan schrijvers? Is Is het het creëren creeren van van een een volwaardig volwaardig literair litterair oeuvre oeuvre voorbehouden voorbehouden aan aan schrijvers schrijvers ? ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) def test013c_correction(self): """Validation - Text Validation on Correction (Double text layers, structural changes)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers? Is het creeren van een volwaardig litterair oeuvre voor behouden aan schrijvers? Is Is het het creëren creeren van van een een volwaardig volwaardig literair litterair oeuvre oeuvre voorbehouden voor behouden aan aan schrijvers schrijvers ? ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) def test013d_correction(self): """Validation - Text Validation on Correction (Double text layers, structural changes, custom class)""" xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers? Is het creeren van een volwaardig litterair oeuvre voor behouden aan schrijvers? Is Is het het creëren creeren van van een een volwaardig volwaardig literair litterair oeuvre oeuvre voorbehouden voor behouden aan aan schrijvers schrijvers ? ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) def test013e_correction(self): """Validation - Text Validation on complex nested correction (Double text layers, structural changes, custom class)""" #NOTE: Current library implementation won't be able to validate nested layers and will just skip those! xml = """

Is het creëren van een volwaardig literair oeuvre voorbehouden aan schrijvers? Is het creeren van een volwaardig litterair oeuvre voor behouden aan schrijvers? Is het CREEREN van een volwaardig litterair oeuvre voor behouden aan schrijvers? Is Is Is het het het creëren creeren CREEREN van van van een een een volwaardig volwaardig volwaardig literair litterair litterair oeuvre oeuvre oeuvre voorbehouden voor behouden voor behouden aan aan aan schrijvers schrijvers schrijvers ? ? ?

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) def test013f_correction(self): """Validation - Text Validation with redundancy on construction""" #NOTE: Current library implementation won't be able to validate nested layers and will just skip those! doc = folia.Document(id='example',textvalidation=True) text = folia.Text(doc, id=doc.id + '.text.1') text.append( folia.Sentence(doc,id=doc.id + '.s.1', text="De site staat online . ", contents=[ folia.Word(doc,id=doc.id + '.s.1.w.1', text="De"), folia.Word(doc,id=doc.id + '.s.1.w.2', text="site"), folia.Word(doc,id=doc.id + '.s.1.w.3', text="staat"), folia.Word(doc,id=doc.id + '.s.1.w.4', text="online"), folia.Word(doc,id=doc.id + '.s.1.w.5', text=".") ]) ) doc.xmlstring() #serialisation forces validation def test013g_correction(self): """Validation - Text Validation with redundancy on partial construction""" #NOTE: Current library implementation won't be able to validate nested layers and will just skip those! doc = folia.Document(id='example',textvalidation=True) text = folia.Text(doc, id=doc.id + '.text.1') raised = False try: text.append( folia.Sentence(doc,id=doc.id + '.s.1', text="De site staat online . ", contents=[ folia.Word(doc,id=doc.id + '.s.1.w.1', text="De"), folia.Word(doc,id=doc.id + '.s.1.w.2', text="site"), folia.Word(doc,id=doc.id + '.s.1.w.3', text="staat"), ]) ) except folia.InconsistentText: raised = True self.assertTrue(raised) def test014_fullparagraph(self): """Validation - Text Validation with sentence text delimiter inheritance""" xml = """

Versoek van het Zuyd-Hollandse Synode aan Haar Ho. Mo., dat bij het inwilligen van een nieuw octroy de Compagnie een goede somme gelds soude contribueeren tot onderhoud van een Seminarium. Het getal der predikanten in Indiën a°. 1647 gebragt op ’t getal van 28. Verdeelinge van deselve (blz. 12). Versoek van het Zuyd-Hollandse Synode aan Haar Ho. Versoek van het Zuyd-Hollandse Synode aan Haar Ho . Mo. Mo . , dat bij het inwilligen van een nieuw octroy de Compagnie een goede somme gelds soude contribueeren tot onderhoud van een Seminarium. , dat bij het inwilligen van een nieuw octroy de Compagnie een goede somme gelds soude contribueeren tot onderhoud van een Seminarium . Het getal der predikanten in Indiën a°. Het getal der predikanten in Indiën a ° . 1647 gebragt op ’t getal van 28. 1647 gebragt op ’t getal van 28 . Verdeelinge van deselve (blz. 12). Verdeelinge van deselve ( blz. 12 ) .

""".format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) def test015_textwhitespace(self): """Validation - Whitespace in text content sanity check""" xml = """ Dit is een rare test. """.format(version=folia.FOLIAVERSION, generator='pynlpl.formats.folia-v' + folia.LIBVERSION) doc = folia.Document(string=xml, textvalidation=True) self.assertEqual( doc['test.s'].text(), "Dit\n is een rare test.\n ") with io.open(FOLIAPATH + '/test/example.xml', 'r',encoding='utf-8') as foliaexample_f: FOLIAEXAMPLE = foliaexample_f.read() #We cheat, by setting the generator and version attributes to match the library, so xmldiff doesn't complain when we compare against this reference FOLIAEXAMPLE = re.sub(r' version="[^"]*" generator="[^"]*"', ' version="' + folia.FOLIAVERSION + '" generator="pynlpl.formats.folia-v' + folia.LIBVERSION + '"', FOLIAEXAMPLE, re.MULTILINE) #Another cheat, alien namespace attributes are ignored by the folia library, strip them so xmldiff doesn't complain FOLIAEXAMPLE = re.sub(r' xmlns:alien="[^"]*" alien:attrib="[^"]*"', '', FOLIAEXAMPLE, re.MULTILINE) DCOIEXAMPLE=""" WR-P-E-J-0000125009 Aspirine 3D model van Aspirine 2009-01-27 Europe NL/B D-Coi Dutch 162304 Unknown false Unknown GNU Free Documentation License Wikimedia Foundation (NL/B)
Aspirine 3D model van Aspirine

Aspirine is een merknaam voor een medicijn van Bayer . De werkzame stof is acetylsalicylzuur . Aspirine is ook bekend onder de naam acetosal en aspro , dat een merknaam is van Nicholas Ltd. Het werkt pijnstillend , koortsverlagend en ontstekingsremmend .

Oorspronkelijk is de werking van salicylzuur als pijnstiller ontdekt doordat het werd geïdentificeerd als de werkzame stof in wilgenbast . Het zuur zelf werd echter bijzonder slecht door de maag getolereerd . De acetyl-ester is daarin veel beter . Deze stof wordt in zuivere toestand of als het iets minder maagprikkelende calciumzout op de markt gebracht ( ascal )

De werking zelf berust erop dat Aspirine irreversibel bindt aan het enzym cyclo-oxygenase ( COX ) , waardoor dit niet meer kan helpen arachidonzuur om te zetten in prostaglandines , stoffen die de zenuwuiteinden gevoelig maken voor prikkels . De vermelde maagproblemen ontstaan door de irreversibele binding aan COX-1 , een variant van het enzym die een rolspeelt bij bescherming van de maag tegen zijn eigen zure inhoud . Ook is dit COX-1 aanwezig in bloedplaatjes , vandaar de trombocytenaggregatieremmende werking . Vandaar dat de farmaceutische industrie zich richt op de ontwikkeling van COX-2 ( induceerbaar COX ) specifieke pijnstillers .

Geschiedenis van Aspirine

De ontdekking van aspirine wordt algemeen toegeschreven aan Felix Hoffmann , werkzaam bij Bayer te Elberfeld . Uit onderzoek van de labjournaals bij Bayer blijkt echter dat de werkelijke ontdekker van aspirine Arthur Eichengrün was , die onderzoek deed naar betere pijnstillers . Felix Hoffmann werkte als laboratorium-assistent onder zijn leiding . Door zijn joodse achtergrond werd Eichengrün door de Nazis uit de annalen geschrapt en werd het verhaal van de rheumatisch vader bedacht . In 1949 publiceerde Eigengrün een artikel waarin hij de uitvinding van aspirine claimde . Deze claim werd bevestigd na onderzoek van Walter Sneader van de universiteit van Glasgow in 1999 . Salicylzuur werd al gebruikt , zelfs Hippocrates kende er de werking van , maar het was een walgelijk goedje dat erg slecht op de maag lag . Dit zuur werd in eerste instantie geëxtraheerd uit bast van leden van de plantenfamilie der wilgen ( Latijnse gelachtsnaam Salix ) , vandaar de naam salicylzuur . Hetzelfde zuur was te vinden in de Moerasspirea , vandaar de ' spir ' in aspirine . Hoffmann ging systematisch te werk en zocht hardnekkig naar een nieuwe verbinding om het middel beter verteerbaar te maken . Volgens het principe van de veredeling van bestaande geneesmiddelen , waarmee hij al eerder succes heeft geboekt , ontdekt hij in 1897 de oplossing van het probleem in de acetylering van het salicylzuur . Op 10 augustus beschrijft hij in zijn laboratoriumdagboek hoe hij het acetylsalicylzuur in chemisch zuivere en bewaarbare vorm heeft samengesteld . Nadat hij de nieuwe stof samen met dokter Heinrich Dreser uitgebreid getest heeft op dieren , komt de stof in 1899 in poedervorm op de markt . Een jaar later zijn er de gedoseerde tabletten . Het wereldverbruik wordt vandaag de dag op vijftigduizend ton of ongeveer honderd miljard tabletten per jaar geschat .

Geschiedenis van Aspro

Tijdens de 1ste Wereldoorlog loofde de Britse regering een prijs uit voor eenieder die een nieuwe formule kon vinden van aspirine , gezien het feit dat de invoer uit Duitsland stil lag . Een chemicus uit het Australische Melbourne , George Nicholas , ontdekte in 1915 een synthetische oplossing , die zelfs zuiverder was dan aspirine en oplosbaar was . Hij noemde dit Aspro , wat later de gehele wereld veroverde .

Pijnstillende werking Aspirine

Pijn wordt veroorzaakt door verschillende stoffen die vrijkomen bij beschadigingen . Werkende cellen in beschadigd weefsel geven die stoffen af , onder invloed van o.a. cytokinen en mitogenen . Deze stoffen werken dan op de zenuwuiteinden die het pijnsignaal naar de hersenen doorsturen . Een hormoon , dat daarin een belangrijke rol speelt is prostaglandine . Prostaglandine geeft niet alleen een pijnsignaal af , maar speelt een belangrijke rol in het hele lichaam . Daarom eerst wat meer over Prostaglandine . Prostaglandine wordt geproduceerd in cellen en werkt alleen in de buurt waar het geproduceerd is en wordt dan afgebroken . Het stimuleert naast de pijnreactie ook de ontstekingsreactie wanneer er een infectie is en zorgt voor de verhoging van de lichaamstemperatuur . In de cellen speelt het cyclooxygenase ( COX ) enzym een onmisbare rol in het maken van prostaglandine . Cyclooxygenase katalyseert de omzetting van arachidonzuur naar prostaglandine , een reactie die anders vrijwel niet verloopt . De aspirine voorkomt de werking van Cyclooxygenase en voorkomt daarmee de vorming van prostaglandine , waardoor een groot gedeelte van de pijn verdwijnt , en ook de koorts en de ontsteking geremd worden , omdat dat de prostaglandine deze reacties niet meer kan veroorzaken . Aspirine is dus een inhibitor , een stof die de werking van een eiwit , in dit geval die van COX , remt of stopt . Daarnaast speelt prostaglandine ook nog een rol in het normaal functioneren . De prostaglandine die wordt gemaakt door COX-1 werkt in de normale processen , als boodschapper . De prostaglandine die werkt bij beschadiging en die een rol speelt in het pijnsignaal , wordt gemaakt door COX-2 . COX-1 kan als het niet functioneert maagbloedingen e.d. veroorzaken . Er is een sinds een aantal jaren een aantal andere geneesmiddelen op de markt die selectief COX-2 remmen . Zie COX-2 remmers .

Andere werkingen Werking op de bloedplaatjes

Aspirine is niet alleen een analgeticum ( pijnstillend middel ) , maar het heeft ook nog andere effecten op ons lichaam . Aspirine heeft een ( onomkeerbaar ) effect op de bloedplaatjes en belemmert deze om samen te klonteren : het is een trombocytenaggregatieremmer . Hierdoor vermindert het stelpend vermogen van het bloed bij bloedvatbeschadiging . De vaak gebruikte benaming ' bloedverdunner ' is onjuist - het bloed wordt niet dunner . Dit effect treedt al op na 1/4 aspirinetablet en houdt aan tot de uitgeschakelde bloedplaatjes ( na ongeveer een week ) allemaal zijn vervangen . Voor dit laatste effect wordt het middel tegenwoordig zeer veel voorgeschreven aan mensen die eerder een beroerte of hartaanval hebben gehad ; het vermindert de kans op herhaling met ca 40 % .

Andere

Ook op het gebied van de kanker-preventie liggen er mogelijk toepassingen voor aspirine , aangezien deze tumorvorming tegengaat . Het dagelijks slikken van een kleine dosis aspirine , gedurende 5 jaar , zou de kans op tumoren in slokdarm en darmstelsel met twee derde doen afnemen . Naar het schijnt heeft aspirine ook een positieve werking tegen de ziekte van Alzheimer , zwangerschaps- , darm- , hart- en vaatziekten .

Bijwerkingen

Aspirine is vrij sterk maagprikkelend : als het nu als nieuw geneesmiddel zou moeten worden geregistreerd als pijnstiller zou dat waarschijnlijk niet lukken . Bij gebruik kunnen maag-klachten en zelfs maagbloedingen ontstaan . Aspirine heeft vooral in hoge doseringen ernstige bijwerkingen , met name de al genoemde maagbloedingen maar ook oorsuizen en doofheid kunnen optreden . Ook weet men dat het gebruik ervan tijdelijk de aanmaak van testosteron vermindert , maar dit neveneffect heeft geen blijvende of erg schadelijke werking . Naast gebruik bij zwangerschap of toediening aan baby's , wordt aspirine liefst ook niet met alcohol gebruikt , omdat dit de kans op maagklachten kan verhogen .

Advies voor gebruik als pijnstiller

Voor gebruik als eenvoudige pijnstiller wordt medisch gezien algemeen de voorkeur gegeven aan paracetamol .

Synthese van aspirine

Bij het maken van acetylsalicylzuur ( aspirine ) op laboratorium schaal gaat het om een opbrengst van enkele grammen . Bij de bereiding van aspirine kan worden uitgegaan van verschillende begin producten , in deze beschrijving wordt uitgegaan van de beginstof salicylzuur . Dit heeft als voordeel dat er maar een synthese stap uitgevoerd hoeft te worden . Uitgaande van salicylzuur en azijnzuuranhydride , wordt salicylzuur veresterd volgens nevenstaande reactie :

Zoals te zien boven de reactiepijl vindt deze synthese plaats in een zuur milieu . In dit geval is gekozen voor geconcentreerd fosforzuur . Na de reactie moet het hoofdproduct ( aspirine ) gescheiden worden van de bijproducten ( azijnzuur en niet gereageerde reactanten ) , dit gebeurt door middel van herkristallisatie . De herkristallisatie wordt uitgevoerd door het ruwe product op te lossen in methanol ( in een reflux opstelling ) en dan net genoeg water toe te voegen zodat de verontreinigingen uitkristalliseren , maar de aspirine niet . Het hete mengsel wordt nu gefiltreerd , waardoor de verontreinigingen op het filter achterblijven en alleen de zuivere aspirine in het filtraat komt . Na deze filtratie wordt het filtraat gekoeld en opnieuw gefiltreerd , de gezuiverde aspirine blijft nu achter op het filter . De verkregen aspirine kan nu worden gedroogd en is klaar voor verpakking of gebruik .

Backmatter bli bli bla, bla bla bli """ if __name__ == '__main__': unittest.main()