repository_name
stringlengths
5
67
func_path_in_repository
stringlengths
4
234
func_name
stringlengths
0
314
whole_func_string
stringlengths
52
3.87M
language
stringclasses
6 values
func_code_string
stringlengths
52
3.87M
func_code_tokens
sequencelengths
15
672k
func_documentation_string
stringlengths
1
47.2k
func_documentation_tokens
sequencelengths
1
3.92k
split_name
stringclasses
1 value
func_code_url
stringlengths
85
339
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.addidsuffix
def addidsuffix(self, idsuffix, recursive = True): """Appends a suffix to this element's ID, and optionally to all child IDs as well. There is sually no need to call this directly, invoked implicitly by :meth:`copy`""" if self.id: self.id += idsuffix if recursive: for e in self: try: e.addidsuffix(idsuffix, recursive) except Exception: pass
python
def addidsuffix(self, idsuffix, recursive = True): """Appends a suffix to this element's ID, and optionally to all child IDs as well. There is sually no need to call this directly, invoked implicitly by :meth:`copy`""" if self.id: self.id += idsuffix if recursive: for e in self: try: e.addidsuffix(idsuffix, recursive) except Exception: pass
[ "def", "addidsuffix", "(", "self", ",", "idsuffix", ",", "recursive", "=", "True", ")", ":", "if", "self", ".", "id", ":", "self", ".", "id", "+=", "idsuffix", "if", "recursive", ":", "for", "e", "in", "self", ":", "try", ":", "e", ".", "addidsuffix", "(", "idsuffix", ",", "recursive", ")", "except", "Exception", ":", "pass" ]
Appends a suffix to this element's ID, and optionally to all child IDs as well. There is sually no need to call this directly, invoked implicitly by :meth:`copy`
[ "Appends", "a", "suffix", "to", "this", "element", "s", "ID", "and", "optionally", "to", "all", "child", "IDs", "as", "well", ".", "There", "is", "sually", "no", "need", "to", "call", "this", "directly", "invoked", "implicitly", "by", ":", "meth", ":", "copy" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1263-L1271
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.setparents
def setparents(self): """Correct all parent relations for elements within the scop. There is sually no need to call this directly, invoked implicitly by :meth:`copy`""" for c in self: if isinstance(c, AbstractElement): c.parent = self c.setparents()
python
def setparents(self): """Correct all parent relations for elements within the scop. There is sually no need to call this directly, invoked implicitly by :meth:`copy`""" for c in self: if isinstance(c, AbstractElement): c.parent = self c.setparents()
[ "def", "setparents", "(", "self", ")", ":", "for", "c", "in", "self", ":", "if", "isinstance", "(", "c", ",", "AbstractElement", ")", ":", "c", ".", "parent", "=", "self", "c", ".", "setparents", "(", ")" ]
Correct all parent relations for elements within the scop. There is sually no need to call this directly, invoked implicitly by :meth:`copy`
[ "Correct", "all", "parent", "relations", "for", "elements", "within", "the", "scop", ".", "There", "is", "sually", "no", "need", "to", "call", "this", "directly", "invoked", "implicitly", "by", ":", "meth", ":", "copy" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1273-L1278
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.setdoc
def setdoc(self,newdoc): """Set a different document. Usually no need to call this directly, invoked implicitly by :meth:`copy`""" self.doc = newdoc if self.doc and self.id: self.doc.index[self.id] = self for c in self: if isinstance(c, AbstractElement): c.setdoc(newdoc)
python
def setdoc(self,newdoc): """Set a different document. Usually no need to call this directly, invoked implicitly by :meth:`copy`""" self.doc = newdoc if self.doc and self.id: self.doc.index[self.id] = self for c in self: if isinstance(c, AbstractElement): c.setdoc(newdoc)
[ "def", "setdoc", "(", "self", ",", "newdoc", ")", ":", "self", ".", "doc", "=", "newdoc", "if", "self", ".", "doc", "and", "self", ".", "id", ":", "self", ".", "doc", ".", "index", "[", "self", ".", "id", "]", "=", "self", "for", "c", "in", "self", ":", "if", "isinstance", "(", "c", ",", "AbstractElement", ")", ":", "c", ".", "setdoc", "(", "newdoc", ")" ]
Set a different document. Usually no need to call this directly, invoked implicitly by :meth:`copy`
[ "Set", "a", "different", "document", ".", "Usually", "no", "need", "to", "call", "this", "directly", "invoked", "implicitly", "by", ":", "meth", ":", "copy" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1280-L1287
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.hastext
def hastext(self,cls='current',strict=True, correctionhandling=CorrectionHandling.CURRENT): #pylint: disable=too-many-return-statements """Does this element have text (of the specified class) By default, and unlike :meth:`text`, this checks strictly, i.e. the element itself must have the text and it is not inherited from its children. Parameters: cls (str): The class of the text content to obtain, defaults to ``current``. strict (bool): Set this if you are strictly interested in the text explicitly associated with the element, without recursing into children. Defaults to ``True``. correctionhandling: Specifies what text to check for when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current text. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the text prior to correction, and ``CorrectionHandling.EITHER`` if you don't care. Returns: bool """ if not self.PRINTABLE: #only printable elements can hold text return False elif self.TEXTCONTAINER: return True else: try: if strict: self.textcontent(cls, correctionhandling) #will raise NoSuchTextException when not found return True else: #Check children for e in self: if e.PRINTABLE and not isinstance(e, TextContent): if e.hastext(cls, strict, correctionhandling): return True self.textcontent(cls, correctionhandling) #will raise NoSuchTextException when not found return True except NoSuchText: return False
python
def hastext(self,cls='current',strict=True, correctionhandling=CorrectionHandling.CURRENT): #pylint: disable=too-many-return-statements """Does this element have text (of the specified class) By default, and unlike :meth:`text`, this checks strictly, i.e. the element itself must have the text and it is not inherited from its children. Parameters: cls (str): The class of the text content to obtain, defaults to ``current``. strict (bool): Set this if you are strictly interested in the text explicitly associated with the element, without recursing into children. Defaults to ``True``. correctionhandling: Specifies what text to check for when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current text. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the text prior to correction, and ``CorrectionHandling.EITHER`` if you don't care. Returns: bool """ if not self.PRINTABLE: #only printable elements can hold text return False elif self.TEXTCONTAINER: return True else: try: if strict: self.textcontent(cls, correctionhandling) #will raise NoSuchTextException when not found return True else: #Check children for e in self: if e.PRINTABLE and not isinstance(e, TextContent): if e.hastext(cls, strict, correctionhandling): return True self.textcontent(cls, correctionhandling) #will raise NoSuchTextException when not found return True except NoSuchText: return False
[ "def", "hastext", "(", "self", ",", "cls", "=", "'current'", ",", "strict", "=", "True", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ")", ":", "#pylint: disable=too-many-return-statements", "if", "not", "self", ".", "PRINTABLE", ":", "#only printable elements can hold text", "return", "False", "elif", "self", ".", "TEXTCONTAINER", ":", "return", "True", "else", ":", "try", ":", "if", "strict", ":", "self", ".", "textcontent", "(", "cls", ",", "correctionhandling", ")", "#will raise NoSuchTextException when not found", "return", "True", "else", ":", "#Check children", "for", "e", "in", "self", ":", "if", "e", ".", "PRINTABLE", "and", "not", "isinstance", "(", "e", ",", "TextContent", ")", ":", "if", "e", ".", "hastext", "(", "cls", ",", "strict", ",", "correctionhandling", ")", ":", "return", "True", "self", ".", "textcontent", "(", "cls", ",", "correctionhandling", ")", "#will raise NoSuchTextException when not found", "return", "True", "except", "NoSuchText", ":", "return", "False" ]
Does this element have text (of the specified class) By default, and unlike :meth:`text`, this checks strictly, i.e. the element itself must have the text and it is not inherited from its children. Parameters: cls (str): The class of the text content to obtain, defaults to ``current``. strict (bool): Set this if you are strictly interested in the text explicitly associated with the element, without recursing into children. Defaults to ``True``. correctionhandling: Specifies what text to check for when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current text. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the text prior to correction, and ``CorrectionHandling.EITHER`` if you don't care. Returns: bool
[ "Does", "this", "element", "have", "text", "(", "of", "the", "specified", "class", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1289-L1321
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.hasphon
def hasphon(self,cls='current',strict=True,correctionhandling=CorrectionHandling.CURRENT): #pylint: disable=too-many-return-statements """Does this element have phonetic content (of the specified class) By default, and unlike :meth:`phon`, this checks strictly, i.e. the element itself must have the phonetic content and it is not inherited from its children. Parameters: cls (str): The class of the phonetic content to obtain, defaults to ``current``. strict (bool): Set this if you are strictly interested in the phonetic content explicitly associated with the element, without recursing into children. Defaults to ``True``. correctionhandling: Specifies what phonetic content to check for when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current phonetic content. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the phonetic content prior to correction, and ``CorrectionHandling.EITHER`` if you don't care. Returns: bool """ if not self.SPEAKABLE: #only printable elements can hold text return False elif self.PHONCONTAINER: return True else: try: if strict: self.phoncontent(cls, correctionhandling) return True else: #Check children for e in self: if e.SPEAKABLE and not isinstance(e, PhonContent): if e.hasphon(cls, strict, correctionhandling): return True self.phoncontent(cls) #will raise NoSuchTextException when not found return True except NoSuchPhon: return False
python
def hasphon(self,cls='current',strict=True,correctionhandling=CorrectionHandling.CURRENT): #pylint: disable=too-many-return-statements """Does this element have phonetic content (of the specified class) By default, and unlike :meth:`phon`, this checks strictly, i.e. the element itself must have the phonetic content and it is not inherited from its children. Parameters: cls (str): The class of the phonetic content to obtain, defaults to ``current``. strict (bool): Set this if you are strictly interested in the phonetic content explicitly associated with the element, without recursing into children. Defaults to ``True``. correctionhandling: Specifies what phonetic content to check for when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current phonetic content. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the phonetic content prior to correction, and ``CorrectionHandling.EITHER`` if you don't care. Returns: bool """ if not self.SPEAKABLE: #only printable elements can hold text return False elif self.PHONCONTAINER: return True else: try: if strict: self.phoncontent(cls, correctionhandling) return True else: #Check children for e in self: if e.SPEAKABLE and not isinstance(e, PhonContent): if e.hasphon(cls, strict, correctionhandling): return True self.phoncontent(cls) #will raise NoSuchTextException when not found return True except NoSuchPhon: return False
[ "def", "hasphon", "(", "self", ",", "cls", "=", "'current'", ",", "strict", "=", "True", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ")", ":", "#pylint: disable=too-many-return-statements", "if", "not", "self", ".", "SPEAKABLE", ":", "#only printable elements can hold text", "return", "False", "elif", "self", ".", "PHONCONTAINER", ":", "return", "True", "else", ":", "try", ":", "if", "strict", ":", "self", ".", "phoncontent", "(", "cls", ",", "correctionhandling", ")", "return", "True", "else", ":", "#Check children", "for", "e", "in", "self", ":", "if", "e", ".", "SPEAKABLE", "and", "not", "isinstance", "(", "e", ",", "PhonContent", ")", ":", "if", "e", ".", "hasphon", "(", "cls", ",", "strict", ",", "correctionhandling", ")", ":", "return", "True", "self", ".", "phoncontent", "(", "cls", ")", "#will raise NoSuchTextException when not found", "return", "True", "except", "NoSuchPhon", ":", "return", "False" ]
Does this element have phonetic content (of the specified class) By default, and unlike :meth:`phon`, this checks strictly, i.e. the element itself must have the phonetic content and it is not inherited from its children. Parameters: cls (str): The class of the phonetic content to obtain, defaults to ``current``. strict (bool): Set this if you are strictly interested in the phonetic content explicitly associated with the element, without recursing into children. Defaults to ``True``. correctionhandling: Specifies what phonetic content to check for when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current phonetic content. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the phonetic content prior to correction, and ``CorrectionHandling.EITHER`` if you don't care. Returns: bool
[ "Does", "this", "element", "have", "phonetic", "content", "(", "of", "the", "specified", "class", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1323-L1355
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.settext
def settext(self, text, cls='current'): """Set the text for this element. Arguments: text (str): The text cls (str): The class of the text, defaults to ``current`` (leave this unless you know what you are doing). There may be only one text content element of each class associated with the element. """ self.replace(TextContent, value=text, cls=cls)
python
def settext(self, text, cls='current'): """Set the text for this element. Arguments: text (str): The text cls (str): The class of the text, defaults to ``current`` (leave this unless you know what you are doing). There may be only one text content element of each class associated with the element. """ self.replace(TextContent, value=text, cls=cls)
[ "def", "settext", "(", "self", ",", "text", ",", "cls", "=", "'current'", ")", ":", "self", ".", "replace", "(", "TextContent", ",", "value", "=", "text", ",", "cls", "=", "cls", ")" ]
Set the text for this element. Arguments: text (str): The text cls (str): The class of the text, defaults to ``current`` (leave this unless you know what you are doing). There may be only one text content element of each class associated with the element.
[ "Set", "the", "text", "for", "this", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1357-L1364
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.setdocument
def setdocument(self, doc): """Associate a document with this element. Arguments: doc (:class:`Document`): A document Each element must be associated with a FoLiA document. """ assert isinstance(doc, Document) if not self.doc: self.doc = doc if self.id: if self.id in doc: raise DuplicateIDError(self.id) else: self.doc.index[id] = self for e in self: #recursive for all children if isinstance(e,AbstractElement): e.setdocument(doc)
python
def setdocument(self, doc): """Associate a document with this element. Arguments: doc (:class:`Document`): A document Each element must be associated with a FoLiA document. """ assert isinstance(doc, Document) if not self.doc: self.doc = doc if self.id: if self.id in doc: raise DuplicateIDError(self.id) else: self.doc.index[id] = self for e in self: #recursive for all children if isinstance(e,AbstractElement): e.setdocument(doc)
[ "def", "setdocument", "(", "self", ",", "doc", ")", ":", "assert", "isinstance", "(", "doc", ",", "Document", ")", "if", "not", "self", ".", "doc", ":", "self", ".", "doc", "=", "doc", "if", "self", ".", "id", ":", "if", "self", ".", "id", "in", "doc", ":", "raise", "DuplicateIDError", "(", "self", ".", "id", ")", "else", ":", "self", ".", "doc", ".", "index", "[", "id", "]", "=", "self", "for", "e", "in", "self", ":", "#recursive for all children", "if", "isinstance", "(", "e", ",", "AbstractElement", ")", ":", "e", ".", "setdocument", "(", "doc", ")" ]
Associate a document with this element. Arguments: doc (:class:`Document`): A document Each element must be associated with a FoLiA document.
[ "Associate", "a", "document", "with", "this", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1366-L1385
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.addable
def addable(Class, parent, set=None, raiseexceptions=True): """Tests whether a new element of this class can be added to the parent. This method is mostly for internal use. This will use the ``OCCURRENCES`` property, but may be overidden by subclasses for more customised behaviour. Parameters: parent (:class:`AbstractElement`): The element that is being added to set (str or None): The set raiseexceptions (bool): Raise an exception if the element can't be added? Returns: bool Raises: ValueError """ if not parent.__class__.accepts(Class, raiseexceptions, parent): return False if Class.OCCURRENCES > 0: #check if the parent doesn't have too many already count = parent.count(Class,None,True,[True, AbstractStructureElement]) #never descend into embedded structure annotatioton if count >= Class.OCCURRENCES: if raiseexceptions: if parent.id: extra = ' (id=' + parent.id + ')' else: extra = '' raise DuplicateAnnotationError("Unable to add another object of type " + Class.__name__ + " to " + parent.__class__.__name__ + " " + extra + ". There are already " + str(count) + " instances of this class, which is the maximum.") else: return False if Class.OCCURRENCES_PER_SET > 0 and set and Class.REQUIRED_ATTRIBS and Attrib.CLASS in Class.REQUIRED_ATTRIBS: count = parent.count(Class,set,True, [True, AbstractStructureElement]) if count >= Class.OCCURRENCES_PER_SET: if raiseexceptions: if parent.id: extra = ' (id=' + parent.id + ')' else: extra = '' raise DuplicateAnnotationError("Unable to add another object of set " + set + " and type " + Class.__name__ + " to " + parent.__class__.__name__ + " " + extra + ". There are already " + str(count) + " instances of this class, which is the maximum for the set.") else: return False return True
python
def addable(Class, parent, set=None, raiseexceptions=True): """Tests whether a new element of this class can be added to the parent. This method is mostly for internal use. This will use the ``OCCURRENCES`` property, but may be overidden by subclasses for more customised behaviour. Parameters: parent (:class:`AbstractElement`): The element that is being added to set (str or None): The set raiseexceptions (bool): Raise an exception if the element can't be added? Returns: bool Raises: ValueError """ if not parent.__class__.accepts(Class, raiseexceptions, parent): return False if Class.OCCURRENCES > 0: #check if the parent doesn't have too many already count = parent.count(Class,None,True,[True, AbstractStructureElement]) #never descend into embedded structure annotatioton if count >= Class.OCCURRENCES: if raiseexceptions: if parent.id: extra = ' (id=' + parent.id + ')' else: extra = '' raise DuplicateAnnotationError("Unable to add another object of type " + Class.__name__ + " to " + parent.__class__.__name__ + " " + extra + ". There are already " + str(count) + " instances of this class, which is the maximum.") else: return False if Class.OCCURRENCES_PER_SET > 0 and set and Class.REQUIRED_ATTRIBS and Attrib.CLASS in Class.REQUIRED_ATTRIBS: count = parent.count(Class,set,True, [True, AbstractStructureElement]) if count >= Class.OCCURRENCES_PER_SET: if raiseexceptions: if parent.id: extra = ' (id=' + parent.id + ')' else: extra = '' raise DuplicateAnnotationError("Unable to add another object of set " + set + " and type " + Class.__name__ + " to " + parent.__class__.__name__ + " " + extra + ". There are already " + str(count) + " instances of this class, which is the maximum for the set.") else: return False return True
[ "def", "addable", "(", "Class", ",", "parent", ",", "set", "=", "None", ",", "raiseexceptions", "=", "True", ")", ":", "if", "not", "parent", ".", "__class__", ".", "accepts", "(", "Class", ",", "raiseexceptions", ",", "parent", ")", ":", "return", "False", "if", "Class", ".", "OCCURRENCES", ">", "0", ":", "#check if the parent doesn't have too many already", "count", "=", "parent", ".", "count", "(", "Class", ",", "None", ",", "True", ",", "[", "True", ",", "AbstractStructureElement", "]", ")", "#never descend into embedded structure annotatioton", "if", "count", ">=", "Class", ".", "OCCURRENCES", ":", "if", "raiseexceptions", ":", "if", "parent", ".", "id", ":", "extra", "=", "' (id='", "+", "parent", ".", "id", "+", "')'", "else", ":", "extra", "=", "''", "raise", "DuplicateAnnotationError", "(", "\"Unable to add another object of type \"", "+", "Class", ".", "__name__", "+", "\" to \"", "+", "parent", ".", "__class__", ".", "__name__", "+", "\" \"", "+", "extra", "+", "\". There are already \"", "+", "str", "(", "count", ")", "+", "\" instances of this class, which is the maximum.\"", ")", "else", ":", "return", "False", "if", "Class", ".", "OCCURRENCES_PER_SET", ">", "0", "and", "set", "and", "Class", ".", "REQUIRED_ATTRIBS", "and", "Attrib", ".", "CLASS", "in", "Class", ".", "REQUIRED_ATTRIBS", ":", "count", "=", "parent", ".", "count", "(", "Class", ",", "set", ",", "True", ",", "[", "True", ",", "AbstractStructureElement", "]", ")", "if", "count", ">=", "Class", ".", "OCCURRENCES_PER_SET", ":", "if", "raiseexceptions", ":", "if", "parent", ".", "id", ":", "extra", "=", "' (id='", "+", "parent", ".", "id", "+", "')'", "else", ":", "extra", "=", "''", "raise", "DuplicateAnnotationError", "(", "\"Unable to add another object of set \"", "+", "set", "+", "\" and type \"", "+", "Class", ".", "__name__", "+", "\" to \"", "+", "parent", ".", "__class__", ".", "__name__", "+", "\" \"", "+", "extra", "+", "\". There are already \"", "+", "str", "(", "count", ")", "+", "\" instances of this class, which is the maximum for the set.\"", ")", "else", ":", "return", "False", "return", "True" ]
Tests whether a new element of this class can be added to the parent. This method is mostly for internal use. This will use the ``OCCURRENCES`` property, but may be overidden by subclasses for more customised behaviour. Parameters: parent (:class:`AbstractElement`): The element that is being added to set (str or None): The set raiseexceptions (bool): Raise an exception if the element can't be added? Returns: bool Raises: ValueError
[ "Tests", "whether", "a", "new", "element", "of", "this", "class", "can", "be", "added", "to", "the", "parent", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1406-L1455
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.postappend
def postappend(self): """This method will be called after an element is added to another and does some checks. It can do extra checks and if necessary raise exceptions to prevent addition. By default makes sure the right document is associated. This method is mostly for internal use. """ #If the element was not associated with a document yet, do so now (and for all unassociated children: if not self.doc and self.parent.doc: self.setdocument(self.parent.doc) if self.doc and self.doc.deepvalidation: self.deepvalidation()
python
def postappend(self): """This method will be called after an element is added to another and does some checks. It can do extra checks and if necessary raise exceptions to prevent addition. By default makes sure the right document is associated. This method is mostly for internal use. """ #If the element was not associated with a document yet, do so now (and for all unassociated children: if not self.doc and self.parent.doc: self.setdocument(self.parent.doc) if self.doc and self.doc.deepvalidation: self.deepvalidation()
[ "def", "postappend", "(", "self", ")", ":", "#If the element was not associated with a document yet, do so now (and for all unassociated children:", "if", "not", "self", ".", "doc", "and", "self", ".", "parent", ".", "doc", ":", "self", ".", "setdocument", "(", "self", ".", "parent", ".", "doc", ")", "if", "self", ".", "doc", "and", "self", ".", "doc", ".", "deepvalidation", ":", "self", ".", "deepvalidation", "(", ")" ]
This method will be called after an element is added to another and does some checks. It can do extra checks and if necessary raise exceptions to prevent addition. By default makes sure the right document is associated. This method is mostly for internal use.
[ "This", "method", "will", "be", "called", "after", "an", "element", "is", "added", "to", "another", "and", "does", "some", "checks", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1458-L1471
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.deepvalidation
def deepvalidation(self): """Perform deep validation of this element. Raises: :class:`DeepValidationError` """ if self.doc and self.doc.deepvalidation and self.set and self.set[0] != '_': try: self.doc.setdefinitions[self.set].testclass(self.cls) except KeyError: if self.cls and not self.doc.allowadhocsets: raise DeepValidationError("Set definition " + self.set + " for " + self.XMLTAG + " not loaded!") except DeepValidationError as e: errormsg = str(e) + " (in set " + self.set+" for " + self.XMLTAG if self.id: errormsg += " with ID " + self.id errormsg += ")" raise DeepValidationError(errormsg)
python
def deepvalidation(self): """Perform deep validation of this element. Raises: :class:`DeepValidationError` """ if self.doc and self.doc.deepvalidation and self.set and self.set[0] != '_': try: self.doc.setdefinitions[self.set].testclass(self.cls) except KeyError: if self.cls and not self.doc.allowadhocsets: raise DeepValidationError("Set definition " + self.set + " for " + self.XMLTAG + " not loaded!") except DeepValidationError as e: errormsg = str(e) + " (in set " + self.set+" for " + self.XMLTAG if self.id: errormsg += " with ID " + self.id errormsg += ")" raise DeepValidationError(errormsg)
[ "def", "deepvalidation", "(", "self", ")", ":", "if", "self", ".", "doc", "and", "self", ".", "doc", ".", "deepvalidation", "and", "self", ".", "set", "and", "self", ".", "set", "[", "0", "]", "!=", "'_'", ":", "try", ":", "self", ".", "doc", ".", "setdefinitions", "[", "self", ".", "set", "]", ".", "testclass", "(", "self", ".", "cls", ")", "except", "KeyError", ":", "if", "self", ".", "cls", "and", "not", "self", ".", "doc", ".", "allowadhocsets", ":", "raise", "DeepValidationError", "(", "\"Set definition \"", "+", "self", ".", "set", "+", "\" for \"", "+", "self", ".", "XMLTAG", "+", "\" not loaded!\"", ")", "except", "DeepValidationError", "as", "e", ":", "errormsg", "=", "str", "(", "e", ")", "+", "\" (in set \"", "+", "self", ".", "set", "+", "\" for \"", "+", "self", ".", "XMLTAG", "if", "self", ".", "id", ":", "errormsg", "+=", "\" with ID \"", "+", "self", ".", "id", "errormsg", "+=", "\")\"", "raise", "DeepValidationError", "(", "errormsg", ")" ]
Perform deep validation of this element. Raises: :class:`DeepValidationError`
[ "Perform", "deep", "validation", "of", "this", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1486-L1503
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.findreplaceables
def findreplaceables(Class, parent, set=None,**kwargs): """Internal method to find replaceable elements. Auxiliary function used by :meth:`AbstractElement.replace`. Can be overriden for more fine-grained control.""" return list(parent.select(Class,set,False))
python
def findreplaceables(Class, parent, set=None,**kwargs): """Internal method to find replaceable elements. Auxiliary function used by :meth:`AbstractElement.replace`. Can be overriden for more fine-grained control.""" return list(parent.select(Class,set,False))
[ "def", "findreplaceables", "(", "Class", ",", "parent", ",", "set", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "list", "(", "parent", ".", "select", "(", "Class", ",", "set", ",", "False", ")", ")" ]
Internal method to find replaceable elements. Auxiliary function used by :meth:`AbstractElement.replace`. Can be overriden for more fine-grained control.
[ "Internal", "method", "to", "find", "replaceable", "elements", ".", "Auxiliary", "function", "used", "by", ":", "meth", ":", "AbstractElement", ".", "replace", ".", "Can", "be", "overriden", "for", "more", "fine", "-", "grained", "control", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1766-L1768
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.updatetext
def updatetext(self): """Recompute textual value based on the text content of the children. Only supported on elements that are a ``TEXTCONTAINER``""" if self.TEXTCONTAINER: s = "" for child in self: if isinstance(child, AbstractElement): child.updatetext() s += child.text() elif isstring(child): s += child self.data = [s]
python
def updatetext(self): """Recompute textual value based on the text content of the children. Only supported on elements that are a ``TEXTCONTAINER``""" if self.TEXTCONTAINER: s = "" for child in self: if isinstance(child, AbstractElement): child.updatetext() s += child.text() elif isstring(child): s += child self.data = [s]
[ "def", "updatetext", "(", "self", ")", ":", "if", "self", ".", "TEXTCONTAINER", ":", "s", "=", "\"\"", "for", "child", "in", "self", ":", "if", "isinstance", "(", "child", ",", "AbstractElement", ")", ":", "child", ".", "updatetext", "(", ")", "s", "+=", "child", ".", "text", "(", ")", "elif", "isstring", "(", "child", ")", ":", "s", "+=", "child", "self", ".", "data", "=", "[", "s", "]" ]
Recompute textual value based on the text content of the children. Only supported on elements that are a ``TEXTCONTAINER``
[ "Recompute", "textual", "value", "based", "on", "the", "text", "content", "of", "the", "children", ".", "Only", "supported", "on", "elements", "that", "are", "a", "TEXTCONTAINER" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1772-L1782
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.replace
def replace(self, child, *args, **kwargs): """Appends a child element like ``append()``, but replaces any existing child element of the same type and set. If no such child element exists, this will act the same as append() Keyword arguments: alternative (bool): If set to True, the *replaced* element will be made into an alternative. Simply use :meth:`AbstractElement.append` if you want the added element to be an alternative. See :meth:`AbstractElement.append` for more information and all parameters. """ if 'set' in kwargs: set = kwargs['set'] del kwargs['set'] else: try: set = child.set except AttributeError: set = None if inspect.isclass(child): Class = child replace = Class.findreplaceables(self, set, **kwargs) elif (self.TEXTCONTAINER or self.PHONCONTAINER) and isstring(child): #replace will replace ALL text content, removing text markup along the way! self.data = [] return self.append(child, *args,**kwargs) else: Class = child.__class__ kwargs['instance'] = child replace = Class.findreplaceables(self,set,**kwargs) del kwargs['instance'] kwargs['set'] = set #was deleted temporarily for findreplaceables if len(replace) == 0: #nothing to replace, simply call append if 'alternative' in kwargs: del kwargs['alternative'] #has other meaning in append() return self.append(child, *args, **kwargs) elif len(replace) > 1: raise Exception("Unable to replace. Multiple candidates found, unable to choose.") elif len(replace) == 1: if 'alternative' in kwargs and kwargs['alternative']: #old version becomes alternative if replace[0] in self.data: self.data.remove(replace[0]) alt = self.append(Alternative) alt.append(replace[0]) del kwargs['alternative'] #has other meaning in append() else: #remove old version competely self.remove(replace[0]) e = self.append(child, *args, **kwargs) self.updatetext() return e
python
def replace(self, child, *args, **kwargs): """Appends a child element like ``append()``, but replaces any existing child element of the same type and set. If no such child element exists, this will act the same as append() Keyword arguments: alternative (bool): If set to True, the *replaced* element will be made into an alternative. Simply use :meth:`AbstractElement.append` if you want the added element to be an alternative. See :meth:`AbstractElement.append` for more information and all parameters. """ if 'set' in kwargs: set = kwargs['set'] del kwargs['set'] else: try: set = child.set except AttributeError: set = None if inspect.isclass(child): Class = child replace = Class.findreplaceables(self, set, **kwargs) elif (self.TEXTCONTAINER or self.PHONCONTAINER) and isstring(child): #replace will replace ALL text content, removing text markup along the way! self.data = [] return self.append(child, *args,**kwargs) else: Class = child.__class__ kwargs['instance'] = child replace = Class.findreplaceables(self,set,**kwargs) del kwargs['instance'] kwargs['set'] = set #was deleted temporarily for findreplaceables if len(replace) == 0: #nothing to replace, simply call append if 'alternative' in kwargs: del kwargs['alternative'] #has other meaning in append() return self.append(child, *args, **kwargs) elif len(replace) > 1: raise Exception("Unable to replace. Multiple candidates found, unable to choose.") elif len(replace) == 1: if 'alternative' in kwargs and kwargs['alternative']: #old version becomes alternative if replace[0] in self.data: self.data.remove(replace[0]) alt = self.append(Alternative) alt.append(replace[0]) del kwargs['alternative'] #has other meaning in append() else: #remove old version competely self.remove(replace[0]) e = self.append(child, *args, **kwargs) self.updatetext() return e
[ "def", "replace", "(", "self", ",", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "'set'", "in", "kwargs", ":", "set", "=", "kwargs", "[", "'set'", "]", "del", "kwargs", "[", "'set'", "]", "else", ":", "try", ":", "set", "=", "child", ".", "set", "except", "AttributeError", ":", "set", "=", "None", "if", "inspect", ".", "isclass", "(", "child", ")", ":", "Class", "=", "child", "replace", "=", "Class", ".", "findreplaceables", "(", "self", ",", "set", ",", "*", "*", "kwargs", ")", "elif", "(", "self", ".", "TEXTCONTAINER", "or", "self", ".", "PHONCONTAINER", ")", "and", "isstring", "(", "child", ")", ":", "#replace will replace ALL text content, removing text markup along the way!", "self", ".", "data", "=", "[", "]", "return", "self", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "Class", "=", "child", ".", "__class__", "kwargs", "[", "'instance'", "]", "=", "child", "replace", "=", "Class", ".", "findreplaceables", "(", "self", ",", "set", ",", "*", "*", "kwargs", ")", "del", "kwargs", "[", "'instance'", "]", "kwargs", "[", "'set'", "]", "=", "set", "#was deleted temporarily for findreplaceables", "if", "len", "(", "replace", ")", "==", "0", ":", "#nothing to replace, simply call append", "if", "'alternative'", "in", "kwargs", ":", "del", "kwargs", "[", "'alternative'", "]", "#has other meaning in append()", "return", "self", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", "elif", "len", "(", "replace", ")", ">", "1", ":", "raise", "Exception", "(", "\"Unable to replace. Multiple candidates found, unable to choose.\"", ")", "elif", "len", "(", "replace", ")", "==", "1", ":", "if", "'alternative'", "in", "kwargs", "and", "kwargs", "[", "'alternative'", "]", ":", "#old version becomes alternative", "if", "replace", "[", "0", "]", "in", "self", ".", "data", ":", "self", ".", "data", ".", "remove", "(", "replace", "[", "0", "]", ")", "alt", "=", "self", ".", "append", "(", "Alternative", ")", "alt", ".", "append", "(", "replace", "[", "0", "]", ")", "del", "kwargs", "[", "'alternative'", "]", "#has other meaning in append()", "else", ":", "#remove old version competely", "self", ".", "remove", "(", "replace", "[", "0", "]", ")", "e", "=", "self", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", "self", ".", "updatetext", "(", ")", "return", "e" ]
Appends a child element like ``append()``, but replaces any existing child element of the same type and set. If no such child element exists, this will act the same as append() Keyword arguments: alternative (bool): If set to True, the *replaced* element will be made into an alternative. Simply use :meth:`AbstractElement.append` if you want the added element to be an alternative. See :meth:`AbstractElement.append` for more information and all parameters.
[ "Appends", "a", "child", "element", "like", "append", "()", "but", "replaces", "any", "existing", "child", "element", "of", "the", "same", "type", "and", "set", ".", "If", "no", "such", "child", "element", "exists", "this", "will", "act", "the", "same", "as", "append", "()" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1784-L1838
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.ancestors
def ancestors(self, Class=None): """Generator yielding all ancestors of this element, effectively back-tracing its path to the root element. A tuple of multiple classes may be specified. Arguments: *Class: The class or classes (:class:`AbstractElement` or subclasses). Not instances! Yields: elements (instances derived from :class:`AbstractElement`) """ e = self while e: if e.parent: e = e.parent if not Class or isinstance(e,Class): yield e elif isinstance(Class, tuple): for C in Class: if isinstance(e,C): yield e else: break
python
def ancestors(self, Class=None): """Generator yielding all ancestors of this element, effectively back-tracing its path to the root element. A tuple of multiple classes may be specified. Arguments: *Class: The class or classes (:class:`AbstractElement` or subclasses). Not instances! Yields: elements (instances derived from :class:`AbstractElement`) """ e = self while e: if e.parent: e = e.parent if not Class or isinstance(e,Class): yield e elif isinstance(Class, tuple): for C in Class: if isinstance(e,C): yield e else: break
[ "def", "ancestors", "(", "self", ",", "Class", "=", "None", ")", ":", "e", "=", "self", "while", "e", ":", "if", "e", ".", "parent", ":", "e", "=", "e", ".", "parent", "if", "not", "Class", "or", "isinstance", "(", "e", ",", "Class", ")", ":", "yield", "e", "elif", "isinstance", "(", "Class", ",", "tuple", ")", ":", "for", "C", "in", "Class", ":", "if", "isinstance", "(", "e", ",", "C", ")", ":", "yield", "e", "else", ":", "break" ]
Generator yielding all ancestors of this element, effectively back-tracing its path to the root element. A tuple of multiple classes may be specified. Arguments: *Class: The class or classes (:class:`AbstractElement` or subclasses). Not instances! Yields: elements (instances derived from :class:`AbstractElement`)
[ "Generator", "yielding", "all", "ancestors", "of", "this", "element", "effectively", "back", "-", "tracing", "its", "path", "to", "the", "root", "element", ".", "A", "tuple", "of", "multiple", "classes", "may", "be", "specified", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1840-L1860
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.ancestor
def ancestor(self, *Classes): """Find the most immediate ancestor of the specified type, multiple classes may be specified. Arguments: *Classes: The possible classes (:class:`AbstractElement` or subclasses) to select from. Not instances! Example:: paragraph = word.ancestor(folia.Paragraph) """ for e in self.ancestors(tuple(Classes)): return e raise NoSuchAnnotation
python
def ancestor(self, *Classes): """Find the most immediate ancestor of the specified type, multiple classes may be specified. Arguments: *Classes: The possible classes (:class:`AbstractElement` or subclasses) to select from. Not instances! Example:: paragraph = word.ancestor(folia.Paragraph) """ for e in self.ancestors(tuple(Classes)): return e raise NoSuchAnnotation
[ "def", "ancestor", "(", "self", ",", "*", "Classes", ")", ":", "for", "e", "in", "self", ".", "ancestors", "(", "tuple", "(", "Classes", ")", ")", ":", "return", "e", "raise", "NoSuchAnnotation" ]
Find the most immediate ancestor of the specified type, multiple classes may be specified. Arguments: *Classes: The possible classes (:class:`AbstractElement` or subclasses) to select from. Not instances! Example:: paragraph = word.ancestor(folia.Paragraph)
[ "Find", "the", "most", "immediate", "ancestor", "of", "the", "specified", "type", "multiple", "classes", "may", "be", "specified", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1862-L1874
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.xml
def xml(self, attribs = None,elements = None, skipchildren = False): """Serialises the FoLiA element and all its contents to XML. Arguments are mostly for internal use. Returns: an lxml.etree.Element See also: :meth:`AbstractElement.xmlstring` - for direct string output """ E = ElementMaker(namespace=NSFOLIA,nsmap={None: NSFOLIA, 'xml' : "http://www.w3.org/XML/1998/namespace"}) if not attribs: attribs = {} if not elements: elements = [] if self.id: attribs['{http://www.w3.org/XML/1998/namespace}id'] = self.id #Some attributes only need to be added if they are not the same as what's already set in the declaration if not isinstance(self, AbstractAnnotationLayer): if '{' + NSFOLIA + '}set' not in attribs: #do not override if overloaded function already set it try: if self.set: if not self.ANNOTATIONTYPE in self.doc.annotationdefaults or len(self.doc.annotationdefaults[self.ANNOTATIONTYPE]) != 1 or list(self.doc.annotationdefaults[self.ANNOTATIONTYPE].keys())[0] != self.set: if self.set != None: if self.ANNOTATIONTYPE in self.doc.set_alias and self.set in self.doc.set_alias[self.ANNOTATIONTYPE]: attribs['{' + NSFOLIA + '}set'] = self.doc.set_alias[self.ANNOTATIONTYPE][self.set] #use alias instead else: attribs['{' + NSFOLIA + '}set'] = self.set except AttributeError: pass if '{' + NSFOLIA + '}class' not in attribs: #do not override if caller already set it try: if self.cls: attribs['{' + NSFOLIA + '}class'] = self.cls except AttributeError: pass if '{' + NSFOLIA + '}annotator' not in attribs: #do not override if caller already set it try: if self.annotator and ((not (self.ANNOTATIONTYPE in self.doc.annotationdefaults)) or (not ( 'annotator' in self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set])) or (self.annotator != self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set]['annotator'])): attribs['{' + NSFOLIA + '}annotator'] = self.annotator if self.annotatortype and ((not (self.ANNOTATIONTYPE in self.doc.annotationdefaults)) or (not ('annotatortype' in self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set])) or (self.annotatortype != self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set]['annotatortype'])): if self.annotatortype == AnnotatorType.AUTO: attribs['{' + NSFOLIA + '}annotatortype'] = 'auto' elif self.annotatortype == AnnotatorType.MANUAL: attribs['{' + NSFOLIA + '}annotatortype'] = 'manual' except AttributeError: pass if '{' + NSFOLIA + '}confidence' not in attribs: #do not override if caller already set it if self.confidence: attribs['{' + NSFOLIA + '}confidence'] = str(self.confidence) if '{' + NSFOLIA + '}n' not in attribs: #do not override if caller already set it if self.n: attribs['{' + NSFOLIA + '}n'] = str(self.n) if '{' + NSFOLIA + '}auth' not in attribs: #do not override if caller already set it try: if not self.AUTH or not self.auth: #(former is static, latter isn't) attribs['{' + NSFOLIA + '}auth'] = 'no' except AttributeError: pass if '{' + NSFOLIA + '}datetime' not in attribs: #do not override if caller already set it if self.datetime and ((not (self.ANNOTATIONTYPE in self.doc.annotationdefaults)) or (not ( 'datetime' in self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set])) or (self.datetime != self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set]['datetime'])): attribs['{' + NSFOLIA + '}datetime'] = self.datetime.strftime("%Y-%m-%dT%H:%M:%S") if '{' + NSFOLIA + '}src' not in attribs: #do not override if caller already set it if self.src: attribs['{' + NSFOLIA + '}src'] = self.src if '{' + NSFOLIA + '}speaker' not in attribs: #do not override if caller already set it if self.speaker: attribs['{' + NSFOLIA + '}speaker'] = self.speaker if '{' + NSFOLIA + '}begintime' not in attribs: #do not override if caller already set it if self.begintime: attribs['{' + NSFOLIA + '}begintime'] = "%02d:%02d:%02d.%03d" % self.begintime if '{' + NSFOLIA + '}endtime' not in attribs: #do not override if caller already set it if self.endtime: attribs['{' + NSFOLIA + '}endtime'] = "%02d:%02d:%02d.%03d" % self.endtime if '{' + NSFOLIA + '}textclass' not in attribs: #do not override if caller already set it if self.textclass and self.textclass != "current": attribs['{' + NSFOLIA + '}textclass'] = self.textclass if '{' + NSFOLIA + '}metadata' not in attribs: #do not override if caller already set it if self.metadata: attribs['{' + NSFOLIA + '}metadata'] = self.metadata if self.XLINK: if self.href: attribs['{http://www.w3.org/1999/xlink}href'] = self.href if not self.xlinktype: attribs['{http://www.w3.org/1999/xlink}type'] = "simple" if self.xlinktype: attribs['{http://www.w3.org/1999/xlink}type'] = self.xlinktype if self.xlinklabel: attribs['{http://www.w3.org/1999/xlink}label'] = self.xlinklabel if self.xlinkrole: attribs['{http://www.w3.org/1999/xlink}role'] = self.xlinkrole if self.xlinkshow: attribs['{http://www.w3.org/1999/xlink}show'] = self.xlinkshow if self.xlinktitle: attribs['{http://www.w3.org/1999/xlink}title'] = self.xlinktitle omitchildren = [] #Are there predetermined Features in ACCEPTED_DATA? for c in self.ACCEPTED_DATA: if issubclass(c, Feature) and c.SUBSET: #Do we have any of those? for c2 in self.data: if c2.__class__ is c and c.SUBSET == c2.SUBSET and c2.cls: #Yes, serialize them as attributes attribs[c2.SUBSET] = c2.cls omitchildren.append(c2) #and skip them as elements break #only one e = makeelement(E, '{' + NSFOLIA + '}' + self.XMLTAG, **attribs) if not skipchildren and self.data: #append children, # we want make sure that text elements are in the right order, 'current' class first # so we first put them in a list textelements = [] otherelements = [] for child in self: if isinstance(child, TextContent): if child.cls == 'current': textelements.insert(0, child) else: textelements.append(child) elif not child in omitchildren: otherelements.append(child) for child in textelements+otherelements: if (self.TEXTCONTAINER or self.PHONCONTAINER) and isstring(child): if len(e) == 0: if e.text: e.text += child else: e.text = child else: #add to tail of last child if e[-1].tail: e[-1].tail += child else: e[-1].tail = child else: xml = child.xml() #may return None in rare occassions, meaning we wan to skip if not xml is None: e.append(xml) if elements: #extra elements for e2 in elements: if isinstance(e2, str) or (sys.version < '3' and isinstance(e2, unicode)): if e.text is None: e.text = e2 else: e.text += e2 else: e.append(e2) return e
python
def xml(self, attribs = None,elements = None, skipchildren = False): """Serialises the FoLiA element and all its contents to XML. Arguments are mostly for internal use. Returns: an lxml.etree.Element See also: :meth:`AbstractElement.xmlstring` - for direct string output """ E = ElementMaker(namespace=NSFOLIA,nsmap={None: NSFOLIA, 'xml' : "http://www.w3.org/XML/1998/namespace"}) if not attribs: attribs = {} if not elements: elements = [] if self.id: attribs['{http://www.w3.org/XML/1998/namespace}id'] = self.id #Some attributes only need to be added if they are not the same as what's already set in the declaration if not isinstance(self, AbstractAnnotationLayer): if '{' + NSFOLIA + '}set' not in attribs: #do not override if overloaded function already set it try: if self.set: if not self.ANNOTATIONTYPE in self.doc.annotationdefaults or len(self.doc.annotationdefaults[self.ANNOTATIONTYPE]) != 1 or list(self.doc.annotationdefaults[self.ANNOTATIONTYPE].keys())[0] != self.set: if self.set != None: if self.ANNOTATIONTYPE in self.doc.set_alias and self.set in self.doc.set_alias[self.ANNOTATIONTYPE]: attribs['{' + NSFOLIA + '}set'] = self.doc.set_alias[self.ANNOTATIONTYPE][self.set] #use alias instead else: attribs['{' + NSFOLIA + '}set'] = self.set except AttributeError: pass if '{' + NSFOLIA + '}class' not in attribs: #do not override if caller already set it try: if self.cls: attribs['{' + NSFOLIA + '}class'] = self.cls except AttributeError: pass if '{' + NSFOLIA + '}annotator' not in attribs: #do not override if caller already set it try: if self.annotator and ((not (self.ANNOTATIONTYPE in self.doc.annotationdefaults)) or (not ( 'annotator' in self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set])) or (self.annotator != self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set]['annotator'])): attribs['{' + NSFOLIA + '}annotator'] = self.annotator if self.annotatortype and ((not (self.ANNOTATIONTYPE in self.doc.annotationdefaults)) or (not ('annotatortype' in self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set])) or (self.annotatortype != self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set]['annotatortype'])): if self.annotatortype == AnnotatorType.AUTO: attribs['{' + NSFOLIA + '}annotatortype'] = 'auto' elif self.annotatortype == AnnotatorType.MANUAL: attribs['{' + NSFOLIA + '}annotatortype'] = 'manual' except AttributeError: pass if '{' + NSFOLIA + '}confidence' not in attribs: #do not override if caller already set it if self.confidence: attribs['{' + NSFOLIA + '}confidence'] = str(self.confidence) if '{' + NSFOLIA + '}n' not in attribs: #do not override if caller already set it if self.n: attribs['{' + NSFOLIA + '}n'] = str(self.n) if '{' + NSFOLIA + '}auth' not in attribs: #do not override if caller already set it try: if not self.AUTH or not self.auth: #(former is static, latter isn't) attribs['{' + NSFOLIA + '}auth'] = 'no' except AttributeError: pass if '{' + NSFOLIA + '}datetime' not in attribs: #do not override if caller already set it if self.datetime and ((not (self.ANNOTATIONTYPE in self.doc.annotationdefaults)) or (not ( 'datetime' in self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set])) or (self.datetime != self.doc.annotationdefaults[self.ANNOTATIONTYPE][self.set]['datetime'])): attribs['{' + NSFOLIA + '}datetime'] = self.datetime.strftime("%Y-%m-%dT%H:%M:%S") if '{' + NSFOLIA + '}src' not in attribs: #do not override if caller already set it if self.src: attribs['{' + NSFOLIA + '}src'] = self.src if '{' + NSFOLIA + '}speaker' not in attribs: #do not override if caller already set it if self.speaker: attribs['{' + NSFOLIA + '}speaker'] = self.speaker if '{' + NSFOLIA + '}begintime' not in attribs: #do not override if caller already set it if self.begintime: attribs['{' + NSFOLIA + '}begintime'] = "%02d:%02d:%02d.%03d" % self.begintime if '{' + NSFOLIA + '}endtime' not in attribs: #do not override if caller already set it if self.endtime: attribs['{' + NSFOLIA + '}endtime'] = "%02d:%02d:%02d.%03d" % self.endtime if '{' + NSFOLIA + '}textclass' not in attribs: #do not override if caller already set it if self.textclass and self.textclass != "current": attribs['{' + NSFOLIA + '}textclass'] = self.textclass if '{' + NSFOLIA + '}metadata' not in attribs: #do not override if caller already set it if self.metadata: attribs['{' + NSFOLIA + '}metadata'] = self.metadata if self.XLINK: if self.href: attribs['{http://www.w3.org/1999/xlink}href'] = self.href if not self.xlinktype: attribs['{http://www.w3.org/1999/xlink}type'] = "simple" if self.xlinktype: attribs['{http://www.w3.org/1999/xlink}type'] = self.xlinktype if self.xlinklabel: attribs['{http://www.w3.org/1999/xlink}label'] = self.xlinklabel if self.xlinkrole: attribs['{http://www.w3.org/1999/xlink}role'] = self.xlinkrole if self.xlinkshow: attribs['{http://www.w3.org/1999/xlink}show'] = self.xlinkshow if self.xlinktitle: attribs['{http://www.w3.org/1999/xlink}title'] = self.xlinktitle omitchildren = [] #Are there predetermined Features in ACCEPTED_DATA? for c in self.ACCEPTED_DATA: if issubclass(c, Feature) and c.SUBSET: #Do we have any of those? for c2 in self.data: if c2.__class__ is c and c.SUBSET == c2.SUBSET and c2.cls: #Yes, serialize them as attributes attribs[c2.SUBSET] = c2.cls omitchildren.append(c2) #and skip them as elements break #only one e = makeelement(E, '{' + NSFOLIA + '}' + self.XMLTAG, **attribs) if not skipchildren and self.data: #append children, # we want make sure that text elements are in the right order, 'current' class first # so we first put them in a list textelements = [] otherelements = [] for child in self: if isinstance(child, TextContent): if child.cls == 'current': textelements.insert(0, child) else: textelements.append(child) elif not child in omitchildren: otherelements.append(child) for child in textelements+otherelements: if (self.TEXTCONTAINER or self.PHONCONTAINER) and isstring(child): if len(e) == 0: if e.text: e.text += child else: e.text = child else: #add to tail of last child if e[-1].tail: e[-1].tail += child else: e[-1].tail = child else: xml = child.xml() #may return None in rare occassions, meaning we wan to skip if not xml is None: e.append(xml) if elements: #extra elements for e2 in elements: if isinstance(e2, str) or (sys.version < '3' and isinstance(e2, unicode)): if e.text is None: e.text = e2 else: e.text += e2 else: e.append(e2) return e
[ "def", "xml", "(", "self", ",", "attribs", "=", "None", ",", "elements", "=", "None", ",", "skipchildren", "=", "False", ")", ":", "E", "=", "ElementMaker", "(", "namespace", "=", "NSFOLIA", ",", "nsmap", "=", "{", "None", ":", "NSFOLIA", ",", "'xml'", ":", "\"http://www.w3.org/XML/1998/namespace\"", "}", ")", "if", "not", "attribs", ":", "attribs", "=", "{", "}", "if", "not", "elements", ":", "elements", "=", "[", "]", "if", "self", ".", "id", ":", "attribs", "[", "'{http://www.w3.org/XML/1998/namespace}id'", "]", "=", "self", ".", "id", "#Some attributes only need to be added if they are not the same as what's already set in the declaration", "if", "not", "isinstance", "(", "self", ",", "AbstractAnnotationLayer", ")", ":", "if", "'{'", "+", "NSFOLIA", "+", "'}set'", "not", "in", "attribs", ":", "#do not override if overloaded function already set it", "try", ":", "if", "self", ".", "set", ":", "if", "not", "self", ".", "ANNOTATIONTYPE", "in", "self", ".", "doc", ".", "annotationdefaults", "or", "len", "(", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", ")", "!=", "1", "or", "list", "(", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", ".", "keys", "(", ")", ")", "[", "0", "]", "!=", "self", ".", "set", ":", "if", "self", ".", "set", "!=", "None", ":", "if", "self", ".", "ANNOTATIONTYPE", "in", "self", ".", "doc", ".", "set_alias", "and", "self", ".", "set", "in", "self", ".", "doc", ".", "set_alias", "[", "self", ".", "ANNOTATIONTYPE", "]", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}set'", "]", "=", "self", ".", "doc", ".", "set_alias", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", "#use alias instead", "else", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}set'", "]", "=", "self", ".", "set", "except", "AttributeError", ":", "pass", "if", "'{'", "+", "NSFOLIA", "+", "'}class'", "not", "in", "attribs", ":", "#do not override if caller already set it", "try", ":", "if", "self", ".", "cls", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}class'", "]", "=", "self", ".", "cls", "except", "AttributeError", ":", "pass", "if", "'{'", "+", "NSFOLIA", "+", "'}annotator'", "not", "in", "attribs", ":", "#do not override if caller already set it", "try", ":", "if", "self", ".", "annotator", "and", "(", "(", "not", "(", "self", ".", "ANNOTATIONTYPE", "in", "self", ".", "doc", ".", "annotationdefaults", ")", ")", "or", "(", "not", "(", "'annotator'", "in", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", ")", ")", "or", "(", "self", ".", "annotator", "!=", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", "[", "'annotator'", "]", ")", ")", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}annotator'", "]", "=", "self", ".", "annotator", "if", "self", ".", "annotatortype", "and", "(", "(", "not", "(", "self", ".", "ANNOTATIONTYPE", "in", "self", ".", "doc", ".", "annotationdefaults", ")", ")", "or", "(", "not", "(", "'annotatortype'", "in", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", ")", ")", "or", "(", "self", ".", "annotatortype", "!=", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", "[", "'annotatortype'", "]", ")", ")", ":", "if", "self", ".", "annotatortype", "==", "AnnotatorType", ".", "AUTO", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}annotatortype'", "]", "=", "'auto'", "elif", "self", ".", "annotatortype", "==", "AnnotatorType", ".", "MANUAL", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}annotatortype'", "]", "=", "'manual'", "except", "AttributeError", ":", "pass", "if", "'{'", "+", "NSFOLIA", "+", "'}confidence'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "confidence", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}confidence'", "]", "=", "str", "(", "self", ".", "confidence", ")", "if", "'{'", "+", "NSFOLIA", "+", "'}n'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "n", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}n'", "]", "=", "str", "(", "self", ".", "n", ")", "if", "'{'", "+", "NSFOLIA", "+", "'}auth'", "not", "in", "attribs", ":", "#do not override if caller already set it", "try", ":", "if", "not", "self", ".", "AUTH", "or", "not", "self", ".", "auth", ":", "#(former is static, latter isn't)", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}auth'", "]", "=", "'no'", "except", "AttributeError", ":", "pass", "if", "'{'", "+", "NSFOLIA", "+", "'}datetime'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "datetime", "and", "(", "(", "not", "(", "self", ".", "ANNOTATIONTYPE", "in", "self", ".", "doc", ".", "annotationdefaults", ")", ")", "or", "(", "not", "(", "'datetime'", "in", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", ")", ")", "or", "(", "self", ".", "datetime", "!=", "self", ".", "doc", ".", "annotationdefaults", "[", "self", ".", "ANNOTATIONTYPE", "]", "[", "self", ".", "set", "]", "[", "'datetime'", "]", ")", ")", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}datetime'", "]", "=", "self", ".", "datetime", ".", "strftime", "(", "\"%Y-%m-%dT%H:%M:%S\"", ")", "if", "'{'", "+", "NSFOLIA", "+", "'}src'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "src", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}src'", "]", "=", "self", ".", "src", "if", "'{'", "+", "NSFOLIA", "+", "'}speaker'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "speaker", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}speaker'", "]", "=", "self", ".", "speaker", "if", "'{'", "+", "NSFOLIA", "+", "'}begintime'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "begintime", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}begintime'", "]", "=", "\"%02d:%02d:%02d.%03d\"", "%", "self", ".", "begintime", "if", "'{'", "+", "NSFOLIA", "+", "'}endtime'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "endtime", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}endtime'", "]", "=", "\"%02d:%02d:%02d.%03d\"", "%", "self", ".", "endtime", "if", "'{'", "+", "NSFOLIA", "+", "'}textclass'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "textclass", "and", "self", ".", "textclass", "!=", "\"current\"", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}textclass'", "]", "=", "self", ".", "textclass", "if", "'{'", "+", "NSFOLIA", "+", "'}metadata'", "not", "in", "attribs", ":", "#do not override if caller already set it", "if", "self", ".", "metadata", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}metadata'", "]", "=", "self", ".", "metadata", "if", "self", ".", "XLINK", ":", "if", "self", ".", "href", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}href'", "]", "=", "self", ".", "href", "if", "not", "self", ".", "xlinktype", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}type'", "]", "=", "\"simple\"", "if", "self", ".", "xlinktype", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}type'", "]", "=", "self", ".", "xlinktype", "if", "self", ".", "xlinklabel", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}label'", "]", "=", "self", ".", "xlinklabel", "if", "self", ".", "xlinkrole", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}role'", "]", "=", "self", ".", "xlinkrole", "if", "self", ".", "xlinkshow", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}show'", "]", "=", "self", ".", "xlinkshow", "if", "self", ".", "xlinktitle", ":", "attribs", "[", "'{http://www.w3.org/1999/xlink}title'", "]", "=", "self", ".", "xlinktitle", "omitchildren", "=", "[", "]", "#Are there predetermined Features in ACCEPTED_DATA?", "for", "c", "in", "self", ".", "ACCEPTED_DATA", ":", "if", "issubclass", "(", "c", ",", "Feature", ")", "and", "c", ".", "SUBSET", ":", "#Do we have any of those?", "for", "c2", "in", "self", ".", "data", ":", "if", "c2", ".", "__class__", "is", "c", "and", "c", ".", "SUBSET", "==", "c2", ".", "SUBSET", "and", "c2", ".", "cls", ":", "#Yes, serialize them as attributes", "attribs", "[", "c2", ".", "SUBSET", "]", "=", "c2", ".", "cls", "omitchildren", ".", "append", "(", "c2", ")", "#and skip them as elements", "break", "#only one", "e", "=", "makeelement", "(", "E", ",", "'{'", "+", "NSFOLIA", "+", "'}'", "+", "self", ".", "XMLTAG", ",", "*", "*", "attribs", ")", "if", "not", "skipchildren", "and", "self", ".", "data", ":", "#append children,", "# we want make sure that text elements are in the right order, 'current' class first", "# so we first put them in a list", "textelements", "=", "[", "]", "otherelements", "=", "[", "]", "for", "child", "in", "self", ":", "if", "isinstance", "(", "child", ",", "TextContent", ")", ":", "if", "child", ".", "cls", "==", "'current'", ":", "textelements", ".", "insert", "(", "0", ",", "child", ")", "else", ":", "textelements", ".", "append", "(", "child", ")", "elif", "not", "child", "in", "omitchildren", ":", "otherelements", ".", "append", "(", "child", ")", "for", "child", "in", "textelements", "+", "otherelements", ":", "if", "(", "self", ".", "TEXTCONTAINER", "or", "self", ".", "PHONCONTAINER", ")", "and", "isstring", "(", "child", ")", ":", "if", "len", "(", "e", ")", "==", "0", ":", "if", "e", ".", "text", ":", "e", ".", "text", "+=", "child", "else", ":", "e", ".", "text", "=", "child", "else", ":", "#add to tail of last child", "if", "e", "[", "-", "1", "]", ".", "tail", ":", "e", "[", "-", "1", "]", ".", "tail", "+=", "child", "else", ":", "e", "[", "-", "1", "]", ".", "tail", "=", "child", "else", ":", "xml", "=", "child", ".", "xml", "(", ")", "#may return None in rare occassions, meaning we wan to skip", "if", "not", "xml", "is", "None", ":", "e", ".", "append", "(", "xml", ")", "if", "elements", ":", "#extra elements", "for", "e2", "in", "elements", ":", "if", "isinstance", "(", "e2", ",", "str", ")", "or", "(", "sys", ".", "version", "<", "'3'", "and", "isinstance", "(", "e2", ",", "unicode", ")", ")", ":", "if", "e", ".", "text", "is", "None", ":", "e", ".", "text", "=", "e2", "else", ":", "e", ".", "text", "+=", "e2", "else", ":", "e", ".", "append", "(", "e2", ")", "return", "e" ]
Serialises the FoLiA element and all its contents to XML. Arguments are mostly for internal use. Returns: an lxml.etree.Element See also: :meth:`AbstractElement.xmlstring` - for direct string output
[ "Serialises", "the", "FoLiA", "element", "and", "all", "its", "contents", "to", "XML", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L1877-L2047
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.json
def json(self, attribs=None, recurse=True, ignorelist=False): """Serialises the FoLiA element and all its contents to a Python dictionary suitable for serialisation to JSON. Example:: import json json.dumps(word.json()) Returns: dict """ jsonnode = {} jsonnode['type'] = self.XMLTAG if self.id: jsonnode['id'] = self.id if self.set: jsonnode['set'] = self.set if self.cls: jsonnode['class'] = self.cls if self.annotator: jsonnode['annotator'] = self.annotator if self.annotatortype: if self.annotatortype == AnnotatorType.AUTO: jsonnode['annotatortype'] = "auto" elif self.annotatortype == AnnotatorType.MANUAL: jsonnode['annotatortype'] = "manual" if self.confidence is not None: jsonnode['confidence'] = self.confidence if self.n: jsonnode['n'] = self.n if self.auth: jsonnode['auth'] = self.auth if self.datetime: jsonnode['datetime'] = self.datetime.strftime("%Y-%m-%dT%H:%M:%S") if recurse: #pylint: disable=too-many-nested-blocks jsonnode['children'] = [] if self.TEXTCONTAINER: jsonnode['text'] = self.text() if self.PHONCONTAINER: jsonnode['phon'] = self.phon() for child in self: if self.TEXTCONTAINER and isstring(child): jsonnode['children'].append(child) elif not self.PHONCONTAINER: #check ignore list ignore = False if ignorelist: for e in ignorelist: if isinstance(child,e): ignore = True break if not ignore: jsonnode['children'].append(child.json(attribs,recurse,ignorelist)) if attribs: for attrib in attribs: jsonnode[attrib] = attribs return jsonnode
python
def json(self, attribs=None, recurse=True, ignorelist=False): """Serialises the FoLiA element and all its contents to a Python dictionary suitable for serialisation to JSON. Example:: import json json.dumps(word.json()) Returns: dict """ jsonnode = {} jsonnode['type'] = self.XMLTAG if self.id: jsonnode['id'] = self.id if self.set: jsonnode['set'] = self.set if self.cls: jsonnode['class'] = self.cls if self.annotator: jsonnode['annotator'] = self.annotator if self.annotatortype: if self.annotatortype == AnnotatorType.AUTO: jsonnode['annotatortype'] = "auto" elif self.annotatortype == AnnotatorType.MANUAL: jsonnode['annotatortype'] = "manual" if self.confidence is not None: jsonnode['confidence'] = self.confidence if self.n: jsonnode['n'] = self.n if self.auth: jsonnode['auth'] = self.auth if self.datetime: jsonnode['datetime'] = self.datetime.strftime("%Y-%m-%dT%H:%M:%S") if recurse: #pylint: disable=too-many-nested-blocks jsonnode['children'] = [] if self.TEXTCONTAINER: jsonnode['text'] = self.text() if self.PHONCONTAINER: jsonnode['phon'] = self.phon() for child in self: if self.TEXTCONTAINER and isstring(child): jsonnode['children'].append(child) elif not self.PHONCONTAINER: #check ignore list ignore = False if ignorelist: for e in ignorelist: if isinstance(child,e): ignore = True break if not ignore: jsonnode['children'].append(child.json(attribs,recurse,ignorelist)) if attribs: for attrib in attribs: jsonnode[attrib] = attribs return jsonnode
[ "def", "json", "(", "self", ",", "attribs", "=", "None", ",", "recurse", "=", "True", ",", "ignorelist", "=", "False", ")", ":", "jsonnode", "=", "{", "}", "jsonnode", "[", "'type'", "]", "=", "self", ".", "XMLTAG", "if", "self", ".", "id", ":", "jsonnode", "[", "'id'", "]", "=", "self", ".", "id", "if", "self", ".", "set", ":", "jsonnode", "[", "'set'", "]", "=", "self", ".", "set", "if", "self", ".", "cls", ":", "jsonnode", "[", "'class'", "]", "=", "self", ".", "cls", "if", "self", ".", "annotator", ":", "jsonnode", "[", "'annotator'", "]", "=", "self", ".", "annotator", "if", "self", ".", "annotatortype", ":", "if", "self", ".", "annotatortype", "==", "AnnotatorType", ".", "AUTO", ":", "jsonnode", "[", "'annotatortype'", "]", "=", "\"auto\"", "elif", "self", ".", "annotatortype", "==", "AnnotatorType", ".", "MANUAL", ":", "jsonnode", "[", "'annotatortype'", "]", "=", "\"manual\"", "if", "self", ".", "confidence", "is", "not", "None", ":", "jsonnode", "[", "'confidence'", "]", "=", "self", ".", "confidence", "if", "self", ".", "n", ":", "jsonnode", "[", "'n'", "]", "=", "self", ".", "n", "if", "self", ".", "auth", ":", "jsonnode", "[", "'auth'", "]", "=", "self", ".", "auth", "if", "self", ".", "datetime", ":", "jsonnode", "[", "'datetime'", "]", "=", "self", ".", "datetime", ".", "strftime", "(", "\"%Y-%m-%dT%H:%M:%S\"", ")", "if", "recurse", ":", "#pylint: disable=too-many-nested-blocks", "jsonnode", "[", "'children'", "]", "=", "[", "]", "if", "self", ".", "TEXTCONTAINER", ":", "jsonnode", "[", "'text'", "]", "=", "self", ".", "text", "(", ")", "if", "self", ".", "PHONCONTAINER", ":", "jsonnode", "[", "'phon'", "]", "=", "self", ".", "phon", "(", ")", "for", "child", "in", "self", ":", "if", "self", ".", "TEXTCONTAINER", "and", "isstring", "(", "child", ")", ":", "jsonnode", "[", "'children'", "]", ".", "append", "(", "child", ")", "elif", "not", "self", ".", "PHONCONTAINER", ":", "#check ignore list", "ignore", "=", "False", "if", "ignorelist", ":", "for", "e", "in", "ignorelist", ":", "if", "isinstance", "(", "child", ",", "e", ")", ":", "ignore", "=", "True", "break", "if", "not", "ignore", ":", "jsonnode", "[", "'children'", "]", ".", "append", "(", "child", ".", "json", "(", "attribs", ",", "recurse", ",", "ignorelist", ")", ")", "if", "attribs", ":", "for", "attrib", "in", "attribs", ":", "jsonnode", "[", "attrib", "]", "=", "attribs", "return", "jsonnode" ]
Serialises the FoLiA element and all its contents to a Python dictionary suitable for serialisation to JSON. Example:: import json json.dumps(word.json()) Returns: dict
[ "Serialises", "the", "FoLiA", "element", "and", "all", "its", "contents", "to", "a", "Python", "dictionary", "suitable", "for", "serialisation", "to", "JSON", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2050-L2110
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.xmlstring
def xmlstring(self, pretty_print=False): """Serialises this FoLiA element and all its contents to XML. Returns: str: a string with XML representation for this element and all its children""" s = ElementTree.tostring(self.xml(), xml_declaration=False, pretty_print=pretty_print, encoding='utf-8') if sys.version < '3': if isinstance(s, str): s = unicode(s,'utf-8') #pylint: disable=undefined-variable else: if isinstance(s,bytes): s = str(s,'utf-8') s = s.replace('ns0:','') #ugly patch to get rid of namespace prefix s = s.replace(':ns0','') return s
python
def xmlstring(self, pretty_print=False): """Serialises this FoLiA element and all its contents to XML. Returns: str: a string with XML representation for this element and all its children""" s = ElementTree.tostring(self.xml(), xml_declaration=False, pretty_print=pretty_print, encoding='utf-8') if sys.version < '3': if isinstance(s, str): s = unicode(s,'utf-8') #pylint: disable=undefined-variable else: if isinstance(s,bytes): s = str(s,'utf-8') s = s.replace('ns0:','') #ugly patch to get rid of namespace prefix s = s.replace(':ns0','') return s
[ "def", "xmlstring", "(", "self", ",", "pretty_print", "=", "False", ")", ":", "s", "=", "ElementTree", ".", "tostring", "(", "self", ".", "xml", "(", ")", ",", "xml_declaration", "=", "False", ",", "pretty_print", "=", "pretty_print", ",", "encoding", "=", "'utf-8'", ")", "if", "sys", ".", "version", "<", "'3'", ":", "if", "isinstance", "(", "s", ",", "str", ")", ":", "s", "=", "unicode", "(", "s", ",", "'utf-8'", ")", "#pylint: disable=undefined-variable", "else", ":", "if", "isinstance", "(", "s", ",", "bytes", ")", ":", "s", "=", "str", "(", "s", ",", "'utf-8'", ")", "s", "=", "s", ".", "replace", "(", "'ns0:'", ",", "''", ")", "#ugly patch to get rid of namespace prefix", "s", "=", "s", ".", "replace", "(", "':ns0'", ",", "''", ")", "return", "s" ]
Serialises this FoLiA element and all its contents to XML. Returns: str: a string with XML representation for this element and all its children
[ "Serialises", "this", "FoLiA", "element", "and", "all", "its", "contents", "to", "XML", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2114-L2129
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.select
def select(self, Class, set=None, recursive=True, ignore=True, node=None): #pylint: disable=bad-classmethod-argument,redefined-builtin """Select child elements of the specified class. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. recursive (bool): Select recursively? Descending into child elements? Defaults to ``True``. ignore: A list of Classes to ignore, if set to ``True`` instead of a list, all non-authoritative elements will be skipped (this is the default behaviour and corresponds to the following elements: :class:`Alternative`, :class:`AlternativeLayer`, :class:`Suggestion`, and :class:`folia.Original`. These elements and those contained within are never *authorative*. You may also include the boolean True as a member of a list, if you want to skip additional tags along the predefined non-authoritative ones. * ``node``: Reserved for internal usage, used in recursion. Yields: Elements (instances derived from :class:`AbstractElement`) Example:: for sense in text.select(folia.Sense, 'cornetto', True, [folia.Original, folia.Suggestion, folia.Alternative] ): .. """ #if ignorelist is True: # ignorelist = default_ignore if not node: node = self for e in self.data: #pylint: disable=too-many-nested-blocks if (not self.TEXTCONTAINER and not self.PHONCONTAINER) or isinstance(e, AbstractElement): if ignore is True: try: if not e.auth: continue except AttributeError: #not all elements have auth attribute.. pass elif ignore: #list doignore = False for c in ignore: if c is True: try: if not e.auth: doignore =True break except AttributeError: #not all elements have auth attribute.. pass elif c == e.__class__ or issubclass(e.__class__,c): doignore = True break if doignore: continue if isinstance(e, Class): if not set is None: try: if e.set != set: continue except AttributeError: continue yield e if recursive: for e2 in e.select(Class, set, recursive, ignore, e): if not set is None: try: if e2.set != set: continue except AttributeError: continue yield e2
python
def select(self, Class, set=None, recursive=True, ignore=True, node=None): #pylint: disable=bad-classmethod-argument,redefined-builtin """Select child elements of the specified class. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. recursive (bool): Select recursively? Descending into child elements? Defaults to ``True``. ignore: A list of Classes to ignore, if set to ``True`` instead of a list, all non-authoritative elements will be skipped (this is the default behaviour and corresponds to the following elements: :class:`Alternative`, :class:`AlternativeLayer`, :class:`Suggestion`, and :class:`folia.Original`. These elements and those contained within are never *authorative*. You may also include the boolean True as a member of a list, if you want to skip additional tags along the predefined non-authoritative ones. * ``node``: Reserved for internal usage, used in recursion. Yields: Elements (instances derived from :class:`AbstractElement`) Example:: for sense in text.select(folia.Sense, 'cornetto', True, [folia.Original, folia.Suggestion, folia.Alternative] ): .. """ #if ignorelist is True: # ignorelist = default_ignore if not node: node = self for e in self.data: #pylint: disable=too-many-nested-blocks if (not self.TEXTCONTAINER and not self.PHONCONTAINER) or isinstance(e, AbstractElement): if ignore is True: try: if not e.auth: continue except AttributeError: #not all elements have auth attribute.. pass elif ignore: #list doignore = False for c in ignore: if c is True: try: if not e.auth: doignore =True break except AttributeError: #not all elements have auth attribute.. pass elif c == e.__class__ or issubclass(e.__class__,c): doignore = True break if doignore: continue if isinstance(e, Class): if not set is None: try: if e.set != set: continue except AttributeError: continue yield e if recursive: for e2 in e.select(Class, set, recursive, ignore, e): if not set is None: try: if e2.set != set: continue except AttributeError: continue yield e2
[ "def", "select", "(", "self", ",", "Class", ",", "set", "=", "None", ",", "recursive", "=", "True", ",", "ignore", "=", "True", ",", "node", "=", "None", ")", ":", "#pylint: disable=bad-classmethod-argument,redefined-builtin", "#if ignorelist is True:", "# ignorelist = default_ignore", "if", "not", "node", ":", "node", "=", "self", "for", "e", "in", "self", ".", "data", ":", "#pylint: disable=too-many-nested-blocks", "if", "(", "not", "self", ".", "TEXTCONTAINER", "and", "not", "self", ".", "PHONCONTAINER", ")", "or", "isinstance", "(", "e", ",", "AbstractElement", ")", ":", "if", "ignore", "is", "True", ":", "try", ":", "if", "not", "e", ".", "auth", ":", "continue", "except", "AttributeError", ":", "#not all elements have auth attribute..", "pass", "elif", "ignore", ":", "#list", "doignore", "=", "False", "for", "c", "in", "ignore", ":", "if", "c", "is", "True", ":", "try", ":", "if", "not", "e", ".", "auth", ":", "doignore", "=", "True", "break", "except", "AttributeError", ":", "#not all elements have auth attribute..", "pass", "elif", "c", "==", "e", ".", "__class__", "or", "issubclass", "(", "e", ".", "__class__", ",", "c", ")", ":", "doignore", "=", "True", "break", "if", "doignore", ":", "continue", "if", "isinstance", "(", "e", ",", "Class", ")", ":", "if", "not", "set", "is", "None", ":", "try", ":", "if", "e", ".", "set", "!=", "set", ":", "continue", "except", "AttributeError", ":", "continue", "yield", "e", "if", "recursive", ":", "for", "e2", "in", "e", ".", "select", "(", "Class", ",", "set", ",", "recursive", ",", "ignore", ",", "e", ")", ":", "if", "not", "set", "is", "None", ":", "try", ":", "if", "e2", ".", "set", "!=", "set", ":", "continue", "except", "AttributeError", ":", "continue", "yield", "e2" ]
Select child elements of the specified class. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. recursive (bool): Select recursively? Descending into child elements? Defaults to ``True``. ignore: A list of Classes to ignore, if set to ``True`` instead of a list, all non-authoritative elements will be skipped (this is the default behaviour and corresponds to the following elements: :class:`Alternative`, :class:`AlternativeLayer`, :class:`Suggestion`, and :class:`folia.Original`. These elements and those contained within are never *authorative*. You may also include the boolean True as a member of a list, if you want to skip additional tags along the predefined non-authoritative ones. * ``node``: Reserved for internal usage, used in recursion. Yields: Elements (instances derived from :class:`AbstractElement`) Example:: for sense in text.select(folia.Sense, 'cornetto', True, [folia.Original, folia.Suggestion, folia.Alternative] ): ..
[ "Select", "child", "elements", "of", "the", "specified", "class", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2132-L2201
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.count
def count(self, Class, set=None, recursive=True, ignore=True, node=None): """Like :meth:`AbstractElement.select`, but instead of returning the elements, it merely counts them. Returns: int """ return sum(1 for i in self.select(Class,set,recursive,ignore,node) )
python
def count(self, Class, set=None, recursive=True, ignore=True, node=None): """Like :meth:`AbstractElement.select`, but instead of returning the elements, it merely counts them. Returns: int """ return sum(1 for i in self.select(Class,set,recursive,ignore,node) )
[ "def", "count", "(", "self", ",", "Class", ",", "set", "=", "None", ",", "recursive", "=", "True", ",", "ignore", "=", "True", ",", "node", "=", "None", ")", ":", "return", "sum", "(", "1", "for", "i", "in", "self", ".", "select", "(", "Class", ",", "set", ",", "recursive", ",", "ignore", ",", "node", ")", ")" ]
Like :meth:`AbstractElement.select`, but instead of returning the elements, it merely counts them. Returns: int
[ "Like", ":", "meth", ":", "AbstractElement", ".", "select", "but", "instead", "of", "returning", "the", "elements", "it", "merely", "counts", "them", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2203-L2209
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.items
def items(self, founditems=[]): #pylint: disable=dangerous-default-value """Returns a depth-first flat list of *all* items below this element (not limited to AbstractElement)""" l = [] for e in self.data: if e not in founditems: #prevent going in recursive loops l.append(e) if isinstance(e, AbstractElement): l += e.items(l) return l
python
def items(self, founditems=[]): #pylint: disable=dangerous-default-value """Returns a depth-first flat list of *all* items below this element (not limited to AbstractElement)""" l = [] for e in self.data: if e not in founditems: #prevent going in recursive loops l.append(e) if isinstance(e, AbstractElement): l += e.items(l) return l
[ "def", "items", "(", "self", ",", "founditems", "=", "[", "]", ")", ":", "#pylint: disable=dangerous-default-value", "l", "=", "[", "]", "for", "e", "in", "self", ".", "data", ":", "if", "e", "not", "in", "founditems", ":", "#prevent going in recursive loops", "l", ".", "append", "(", "e", ")", "if", "isinstance", "(", "e", ",", "AbstractElement", ")", ":", "l", "+=", "e", ".", "items", "(", "l", ")", "return", "l" ]
Returns a depth-first flat list of *all* items below this element (not limited to AbstractElement)
[ "Returns", "a", "depth", "-", "first", "flat", "list", "of", "*", "all", "*", "items", "below", "this", "element", "(", "not", "limited", "to", "AbstractElement", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2211-L2219
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.getmetadata
def getmetadata(self, key=None): """Get the metadata that applies to this element, automatically inherited from parent elements""" if self.metadata: d = self.doc.submetadata[self.metadata] elif self.parent: d = self.parent.getmetadata() elif self.doc: d = self.doc.metadata else: return None if key: return d[key] else: return d
python
def getmetadata(self, key=None): """Get the metadata that applies to this element, automatically inherited from parent elements""" if self.metadata: d = self.doc.submetadata[self.metadata] elif self.parent: d = self.parent.getmetadata() elif self.doc: d = self.doc.metadata else: return None if key: return d[key] else: return d
[ "def", "getmetadata", "(", "self", ",", "key", "=", "None", ")", ":", "if", "self", ".", "metadata", ":", "d", "=", "self", ".", "doc", ".", "submetadata", "[", "self", ".", "metadata", "]", "elif", "self", ".", "parent", ":", "d", "=", "self", ".", "parent", ".", "getmetadata", "(", ")", "elif", "self", ".", "doc", ":", "d", "=", "self", ".", "doc", ".", "metadata", "else", ":", "return", "None", "if", "key", ":", "return", "d", "[", "key", "]", "else", ":", "return", "d" ]
Get the metadata that applies to this element, automatically inherited from parent elements
[ "Get", "the", "metadata", "that", "applies", "to", "this", "element", "automatically", "inherited", "from", "parent", "elements" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2221-L2234
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.getindex
def getindex(self, child, recursive=True, ignore=True): """Get the index at which an element occurs, recursive by default! Returns: int """ #breadth first search for i, c in enumerate(self.data): if c is child: return i if recursive: #pylint: disable=too-many-nested-blocks for i, c in enumerate(self.data): if ignore is True: try: if not c.auth: continue except AttributeError: #not all elements have auth attribute.. pass elif ignore: #list doignore = False for e in ignore: if e is True: try: if not c.auth: doignore =True break except AttributeError: #not all elements have auth attribute.. pass elif e == c.__class__ or issubclass(c.__class__,e): doignore = True break if doignore: continue if isinstance(c, AbstractElement): j = c.getindex(child, recursive) if j != -1: return i #yes, i ... not j! return -1
python
def getindex(self, child, recursive=True, ignore=True): """Get the index at which an element occurs, recursive by default! Returns: int """ #breadth first search for i, c in enumerate(self.data): if c is child: return i if recursive: #pylint: disable=too-many-nested-blocks for i, c in enumerate(self.data): if ignore is True: try: if not c.auth: continue except AttributeError: #not all elements have auth attribute.. pass elif ignore: #list doignore = False for e in ignore: if e is True: try: if not c.auth: doignore =True break except AttributeError: #not all elements have auth attribute.. pass elif e == c.__class__ or issubclass(c.__class__,e): doignore = True break if doignore: continue if isinstance(c, AbstractElement): j = c.getindex(child, recursive) if j != -1: return i #yes, i ... not j! return -1
[ "def", "getindex", "(", "self", ",", "child", ",", "recursive", "=", "True", ",", "ignore", "=", "True", ")", ":", "#breadth first search", "for", "i", ",", "c", "in", "enumerate", "(", "self", ".", "data", ")", ":", "if", "c", "is", "child", ":", "return", "i", "if", "recursive", ":", "#pylint: disable=too-many-nested-blocks", "for", "i", ",", "c", "in", "enumerate", "(", "self", ".", "data", ")", ":", "if", "ignore", "is", "True", ":", "try", ":", "if", "not", "c", ".", "auth", ":", "continue", "except", "AttributeError", ":", "#not all elements have auth attribute..", "pass", "elif", "ignore", ":", "#list", "doignore", "=", "False", "for", "e", "in", "ignore", ":", "if", "e", "is", "True", ":", "try", ":", "if", "not", "c", ".", "auth", ":", "doignore", "=", "True", "break", "except", "AttributeError", ":", "#not all elements have auth attribute..", "pass", "elif", "e", "==", "c", ".", "__class__", "or", "issubclass", "(", "c", ".", "__class__", ",", "e", ")", ":", "doignore", "=", "True", "break", "if", "doignore", ":", "continue", "if", "isinstance", "(", "c", ",", "AbstractElement", ")", ":", "j", "=", "c", ".", "getindex", "(", "child", ",", "recursive", ")", "if", "j", "!=", "-", "1", ":", "return", "i", "#yes, i ... not j!", "return", "-", "1" ]
Get the index at which an element occurs, recursive by default! Returns: int
[ "Get", "the", "index", "at", "which", "an", "element", "occurs", "recursive", "by", "default!" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2238-L2278
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.precedes
def precedes(self, other): """Returns a boolean indicating whether this element precedes the other element""" try: ancestor = next(commonancestors(AbstractElement, self, other)) except StopIteration: raise Exception("Elements share no common ancestor") #now we just do a depth first search and see who comes first def callback(e): if e is self: return True elif e is other: return False return None result = ancestor.depthfirstsearch(callback) if result is None: raise Exception("Unable to find relation between elements! (shouldn't happen)") return result
python
def precedes(self, other): """Returns a boolean indicating whether this element precedes the other element""" try: ancestor = next(commonancestors(AbstractElement, self, other)) except StopIteration: raise Exception("Elements share no common ancestor") #now we just do a depth first search and see who comes first def callback(e): if e is self: return True elif e is other: return False return None result = ancestor.depthfirstsearch(callback) if result is None: raise Exception("Unable to find relation between elements! (shouldn't happen)") return result
[ "def", "precedes", "(", "self", ",", "other", ")", ":", "try", ":", "ancestor", "=", "next", "(", "commonancestors", "(", "AbstractElement", ",", "self", ",", "other", ")", ")", "except", "StopIteration", ":", "raise", "Exception", "(", "\"Elements share no common ancestor\"", ")", "#now we just do a depth first search and see who comes first", "def", "callback", "(", "e", ")", ":", "if", "e", "is", "self", ":", "return", "True", "elif", "e", "is", "other", ":", "return", "False", "return", "None", "result", "=", "ancestor", ".", "depthfirstsearch", "(", "callback", ")", "if", "result", "is", "None", ":", "raise", "Exception", "(", "\"Unable to find relation between elements! (shouldn't happen)\"", ")", "return", "result" ]
Returns a boolean indicating whether this element precedes the other element
[ "Returns", "a", "boolean", "indicating", "whether", "this", "element", "precedes", "the", "other", "element" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2280-L2296
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.depthfirstsearch
def depthfirstsearch(self, function): """Generic depth first search algorithm using a callback function, continues as long as the callback function returns None""" result = function(self) if result is not None: return result for e in self: result = e.depthfirstsearch(function) if result is not None: return result return None
python
def depthfirstsearch(self, function): """Generic depth first search algorithm using a callback function, continues as long as the callback function returns None""" result = function(self) if result is not None: return result for e in self: result = e.depthfirstsearch(function) if result is not None: return result return None
[ "def", "depthfirstsearch", "(", "self", ",", "function", ")", ":", "result", "=", "function", "(", "self", ")", "if", "result", "is", "not", "None", ":", "return", "result", "for", "e", "in", "self", ":", "result", "=", "e", ".", "depthfirstsearch", "(", "function", ")", "if", "result", "is", "not", "None", ":", "return", "result", "return", "None" ]
Generic depth first search algorithm using a callback function, continues as long as the callback function returns None
[ "Generic", "depth", "first", "search", "algorithm", "using", "a", "callback", "function", "continues", "as", "long", "as", "the", "callback", "function", "returns", "None" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2299-L2308
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.next
def next(self, Class=True, scope=True, reverse=False): """Returns the next element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``, may also be a tuple of multiple classes. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all. """ if Class is True: Class = self.__class__ if scope is True: scope = STRUCTURESCOPE structural = Class is not None and issubclass(Class,AbstractStructureElement) if reverse: order = reversed descendindex = -1 else: order = lambda x: x #pylint: disable=redefined-variable-type descendindex = 0 child = self parent = self.parent while parent: #pylint: disable=too-many-nested-blocks if len(parent) > 1: returnnext = False for e in order(parent): if e is child: #we found the current item, next item will be the one to return returnnext = True elif returnnext and e.auth and not isinstance(e,AbstractAnnotationLayer) and (not structural or (structural and (not isinstance(e,(AbstractTokenAnnotation,TextContent)) ) )): if structural and isinstance(e,Correction): if not list(e.select(AbstractStructureElement)): #skip-over non-structural correction continue if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #this is not yet the element of the type we are looking for, we are going to descend again in the very leftmost (rightmost if reversed) branch only while e.data: e = e.data[descendindex] if not isinstance(e, AbstractElement): return None #we've gone too far if e.auth and not isinstance(e,AbstractAnnotationLayer): if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #descend deeper continue return None #generational iteration child = parent if scope is not None and child.__class__ in scope: #you shall not pass! break parent = parent.parent return None
python
def next(self, Class=True, scope=True, reverse=False): """Returns the next element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``, may also be a tuple of multiple classes. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all. """ if Class is True: Class = self.__class__ if scope is True: scope = STRUCTURESCOPE structural = Class is not None and issubclass(Class,AbstractStructureElement) if reverse: order = reversed descendindex = -1 else: order = lambda x: x #pylint: disable=redefined-variable-type descendindex = 0 child = self parent = self.parent while parent: #pylint: disable=too-many-nested-blocks if len(parent) > 1: returnnext = False for e in order(parent): if e is child: #we found the current item, next item will be the one to return returnnext = True elif returnnext and e.auth and not isinstance(e,AbstractAnnotationLayer) and (not structural or (structural and (not isinstance(e,(AbstractTokenAnnotation,TextContent)) ) )): if structural and isinstance(e,Correction): if not list(e.select(AbstractStructureElement)): #skip-over non-structural correction continue if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #this is not yet the element of the type we are looking for, we are going to descend again in the very leftmost (rightmost if reversed) branch only while e.data: e = e.data[descendindex] if not isinstance(e, AbstractElement): return None #we've gone too far if e.auth and not isinstance(e,AbstractAnnotationLayer): if Class is None or (isinstance(Class,tuple) and (any(isinstance(e,C) for C in Class))) or isinstance(e,Class): return e else: #descend deeper continue return None #generational iteration child = parent if scope is not None and child.__class__ in scope: #you shall not pass! break parent = parent.parent return None
[ "def", "next", "(", "self", ",", "Class", "=", "True", ",", "scope", "=", "True", ",", "reverse", "=", "False", ")", ":", "if", "Class", "is", "True", ":", "Class", "=", "self", ".", "__class__", "if", "scope", "is", "True", ":", "scope", "=", "STRUCTURESCOPE", "structural", "=", "Class", "is", "not", "None", "and", "issubclass", "(", "Class", ",", "AbstractStructureElement", ")", "if", "reverse", ":", "order", "=", "reversed", "descendindex", "=", "-", "1", "else", ":", "order", "=", "lambda", "x", ":", "x", "#pylint: disable=redefined-variable-type", "descendindex", "=", "0", "child", "=", "self", "parent", "=", "self", ".", "parent", "while", "parent", ":", "#pylint: disable=too-many-nested-blocks", "if", "len", "(", "parent", ")", ">", "1", ":", "returnnext", "=", "False", "for", "e", "in", "order", "(", "parent", ")", ":", "if", "e", "is", "child", ":", "#we found the current item, next item will be the one to return", "returnnext", "=", "True", "elif", "returnnext", "and", "e", ".", "auth", "and", "not", "isinstance", "(", "e", ",", "AbstractAnnotationLayer", ")", "and", "(", "not", "structural", "or", "(", "structural", "and", "(", "not", "isinstance", "(", "e", ",", "(", "AbstractTokenAnnotation", ",", "TextContent", ")", ")", ")", ")", ")", ":", "if", "structural", "and", "isinstance", "(", "e", ",", "Correction", ")", ":", "if", "not", "list", "(", "e", ".", "select", "(", "AbstractStructureElement", ")", ")", ":", "#skip-over non-structural correction", "continue", "if", "Class", "is", "None", "or", "(", "isinstance", "(", "Class", ",", "tuple", ")", "and", "(", "any", "(", "isinstance", "(", "e", ",", "C", ")", "for", "C", "in", "Class", ")", ")", ")", "or", "isinstance", "(", "e", ",", "Class", ")", ":", "return", "e", "else", ":", "#this is not yet the element of the type we are looking for, we are going to descend again in the very leftmost (rightmost if reversed) branch only", "while", "e", ".", "data", ":", "e", "=", "e", ".", "data", "[", "descendindex", "]", "if", "not", "isinstance", "(", "e", ",", "AbstractElement", ")", ":", "return", "None", "#we've gone too far", "if", "e", ".", "auth", "and", "not", "isinstance", "(", "e", ",", "AbstractAnnotationLayer", ")", ":", "if", "Class", "is", "None", "or", "(", "isinstance", "(", "Class", ",", "tuple", ")", "and", "(", "any", "(", "isinstance", "(", "e", ",", "C", ")", "for", "C", "in", "Class", ")", ")", ")", "or", "isinstance", "(", "e", ",", "Class", ")", ":", "return", "e", "else", ":", "#descend deeper", "continue", "return", "None", "#generational iteration", "child", "=", "parent", "if", "scope", "is", "not", "None", "and", "child", ".", "__class__", "in", "scope", ":", "#you shall not pass!", "break", "parent", "=", "parent", ".", "parent", "return", "None" ]
Returns the next element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``, may also be a tuple of multiple classes. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all.
[ "Returns", "the", "next", "element", "if", "it", "is", "of", "the", "specified", "type", "and", "if", "it", "does", "not", "cross", "the", "boundary", "of", "the", "defined", "scope", ".", "Returns", "None", "if", "no", "next", "element", "is", "found", ".", "Non", "-", "authoritative", "elements", "are", "never", "returned", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2310-L2367
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.previous
def previous(self, Class=True, scope=True): """Returns the previous element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all. """ return self.next(Class,scope, True)
python
def previous(self, Class=True, scope=True): """Returns the previous element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all. """ return self.next(Class,scope, True)
[ "def", "previous", "(", "self", ",", "Class", "=", "True", ",", "scope", "=", "True", ")", ":", "return", "self", ".", "next", "(", "Class", ",", "scope", ",", "True", ")" ]
Returns the previous element, if it is of the specified type and if it does not cross the boundary of the defined scope. Returns None if no next element is found. Non-authoritative elements are never returned. Arguments: * ``Class``: The class to select; any python class subclassed off `'AbstractElement``. Set to ``True`` to constrain to the same class as that of the current instance, set to ``None`` to not constrain at all * ``scope``: A list of classes which are never crossed looking for a next element. Set to ``True`` to constrain to a default list of structure elements (Sentence,Paragraph,Division,Event, ListItem,Caption), set to ``None`` to not constrain at all.
[ "Returns", "the", "previous", "element", "if", "it", "is", "of", "the", "specified", "type", "and", "if", "it", "does", "not", "cross", "the", "boundary", "of", "the", "defined", "scope", ".", "Returns", "None", "if", "no", "next", "element", "is", "found", ".", "Non", "-", "authoritative", "elements", "are", "never", "returned", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2371-L2379
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.leftcontext
def leftcontext(self, size, placeholder=None, scope=None): """Returns the left context for an element, as a list. This method crosses sentence/paragraph boundaries by default, which can be restricted by setting scope""" if size == 0: return [] #for efficiency context = [] e = self while len(context) < size: e = e.previous(True,scope) if not e: break context.append(e) if placeholder: while len(context) < size: context.append(placeholder) context.reverse() return context
python
def leftcontext(self, size, placeholder=None, scope=None): """Returns the left context for an element, as a list. This method crosses sentence/paragraph boundaries by default, which can be restricted by setting scope""" if size == 0: return [] #for efficiency context = [] e = self while len(context) < size: e = e.previous(True,scope) if not e: break context.append(e) if placeholder: while len(context) < size: context.append(placeholder) context.reverse() return context
[ "def", "leftcontext", "(", "self", ",", "size", ",", "placeholder", "=", "None", ",", "scope", "=", "None", ")", ":", "if", "size", "==", "0", ":", "return", "[", "]", "#for efficiency", "context", "=", "[", "]", "e", "=", "self", "while", "len", "(", "context", ")", "<", "size", ":", "e", "=", "e", ".", "previous", "(", "True", ",", "scope", ")", "if", "not", "e", ":", "break", "context", ".", "append", "(", "e", ")", "if", "placeholder", ":", "while", "len", "(", "context", ")", "<", "size", ":", "context", ".", "append", "(", "placeholder", ")", "context", ".", "reverse", "(", ")", "return", "context" ]
Returns the left context for an element, as a list. This method crosses sentence/paragraph boundaries by default, which can be restricted by setting scope
[ "Returns", "the", "left", "context", "for", "an", "element", "as", "a", "list", ".", "This", "method", "crosses", "sentence", "/", "paragraph", "boundaries", "by", "default", "which", "can", "be", "restricted", "by", "setting", "scope" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2381-L2398
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.rightcontext
def rightcontext(self, size, placeholder=None, scope=None): """Returns the right context for an element, as a list. This method crosses sentence/paragraph boundaries by default, which can be restricted by setting scope""" if size == 0: return [] #for efficiency context = [] e = self while len(context) < size: e = e.next(True,scope) if not e: break context.append(e) if placeholder: while len(context) < size: context.append(placeholder) return context
python
def rightcontext(self, size, placeholder=None, scope=None): """Returns the right context for an element, as a list. This method crosses sentence/paragraph boundaries by default, which can be restricted by setting scope""" if size == 0: return [] #for efficiency context = [] e = self while len(context) < size: e = e.next(True,scope) if not e: break context.append(e) if placeholder: while len(context) < size: context.append(placeholder) return context
[ "def", "rightcontext", "(", "self", ",", "size", ",", "placeholder", "=", "None", ",", "scope", "=", "None", ")", ":", "if", "size", "==", "0", ":", "return", "[", "]", "#for efficiency", "context", "=", "[", "]", "e", "=", "self", "while", "len", "(", "context", ")", "<", "size", ":", "e", "=", "e", ".", "next", "(", "True", ",", "scope", ")", "if", "not", "e", ":", "break", "context", ".", "append", "(", "e", ")", "if", "placeholder", ":", "while", "len", "(", "context", ")", "<", "size", ":", "context", ".", "append", "(", "placeholder", ")", "return", "context" ]
Returns the right context for an element, as a list. This method crosses sentence/paragraph boundaries by default, which can be restricted by setting scope
[ "Returns", "the", "right", "context", "for", "an", "element", "as", "a", "list", ".", "This", "method", "crosses", "sentence", "/", "paragraph", "boundaries", "by", "default", "which", "can", "be", "restricted", "by", "setting", "scope" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2401-L2417
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.context
def context(self, size, placeholder=None, scope=None): """Returns this word in context, {size} words to the left, the current word, and {size} words to the right""" return self.leftcontext(size, placeholder,scope) + [self] + self.rightcontext(size, placeholder,scope)
python
def context(self, size, placeholder=None, scope=None): """Returns this word in context, {size} words to the left, the current word, and {size} words to the right""" return self.leftcontext(size, placeholder,scope) + [self] + self.rightcontext(size, placeholder,scope)
[ "def", "context", "(", "self", ",", "size", ",", "placeholder", "=", "None", ",", "scope", "=", "None", ")", ":", "return", "self", ".", "leftcontext", "(", "size", ",", "placeholder", ",", "scope", ")", "+", "[", "self", "]", "+", "self", ".", "rightcontext", "(", "size", ",", "placeholder", ",", "scope", ")" ]
Returns this word in context, {size} words to the left, the current word, and {size} words to the right
[ "Returns", "this", "word", "in", "context", "{", "size", "}", "words", "to", "the", "left", "the", "current", "word", "and", "{", "size", "}", "words", "to", "the", "right" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2419-L2421
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.relaxng
def relaxng(cls, includechildren=True,extraattribs = None, extraelements=None, origclass = None): """Returns a RelaxNG definition for this element (as an XML element (lxml.etree) rather than a string)""" E = ElementMaker(namespace="http://relaxng.org/ns/structure/1.0",nsmap={None:'http://relaxng.org/ns/structure/1.0' , 'folia': "http://ilk.uvt.nl/folia", 'xml' : "http://www.w3.org/XML/1998/namespace",'a':"http://relaxng.org/ns/annotation/0.9" }) if origclass: cls = origclass preamble = [] try: if cls.__doc__: E2 = ElementMaker(namespace="http://relaxng.org/ns/annotation/0.9", nsmap={'a':'http://relaxng.org/ns/annotation/0.9'} ) preamble.append(E2.documentation(cls.__doc__)) except AttributeError: pass if cls.REQUIRED_ATTRIBS is None: cls.REQUIRED_ATTRIBS = () #bit hacky if cls.OPTIONAL_ATTRIBS is None: cls.OPTIONAL_ATTRIBS = () #bit hacky attribs = [ ] if cls.REQUIRED_ATTRIBS and Attrib.ID in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute(E.data(type='ID',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='id', ns="http://www.w3.org/XML/1998/namespace") ) elif Attrib.ID in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='ID',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='id', ns="http://www.w3.org/XML/1998/namespace") ) ) if Attrib.CLASS in cls.REQUIRED_ATTRIBS: #Set is a tough one, we can't require it as it may be defined in the declaration: we make it optional and need schematron to resolve this later attribs.append( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='class') ) attribs.append( E.optional( E.attribute( E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='set' ) ) ) elif Attrib.CLASS in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='class') ) ) attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='set' ) ) ) if Attrib.ANNOTATOR in cls.REQUIRED_ATTRIBS or Attrib.ANNOTATOR in cls.OPTIONAL_ATTRIBS: #Similarly tough attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='annotator') ) ) attribs.append( E.optional( E.attribute(name='annotatortype') ) ) if Attrib.CONFIDENCE in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute(E.data(type='double',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='confidence') ) elif Attrib.CONFIDENCE in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='double',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='confidence') ) ) if Attrib.N in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute( E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='n') ) elif Attrib.N in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute( E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='n') ) ) if Attrib.DATETIME in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute(E.data(type='dateTime',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='datetime') ) elif Attrib.DATETIME in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute( E.data(type='dateTime',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='datetime') ) ) if Attrib.BEGINTIME in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='begintime') ) elif Attrib.BEGINTIME in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='begintime') ) ) if Attrib.ENDTIME in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='endtime') ) elif Attrib.ENDTIME in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='endtime') ) ) if Attrib.SRC in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(E.data(type='anyURI',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='src') ) elif Attrib.SRC in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='anyURI',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='src') ) ) if Attrib.SPEAKER in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='speaker') ) elif Attrib.SPEAKER in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='speaker') ) ) if Attrib.TEXTCLASS in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='textclass') ) elif Attrib.TEXTCLASS in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='textclass') ) ) if Attrib.METADATA in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='metadata') ) elif Attrib.METADATA in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='metadata') ) ) if cls.XLINK: attribs += [ #loose interpretation of specs, not checking whether xlink combinations are valid E.optional(E.attribute(name='href',ns="http://www.w3.org/1999/xlink"),E.attribute(name='type',ns="http://www.w3.org/1999/xlink") ), E.optional(E.attribute(name='role',ns="http://www.w3.org/1999/xlink")), E.optional(E.attribute(name='title',ns="http://www.w3.org/1999/xlink")), E.optional(E.attribute(name='label',ns="http://www.w3.org/1999/xlink")), E.optional(E.attribute(name='show',ns="http://www.w3.org/1999/xlink")), ] attribs.append( E.optional( E.attribute( name='auth' ) ) ) if extraattribs: for e in extraattribs: attribs.append(e) #s attribs.append( E.ref(name="allow_foreign_attributes") ) elements = [] #(including attributes) if cls.TEXTCONTAINER or cls.PHONCONTAINER: elements.append( E.text()) #We actually want to require non-empty text (E.text() is not sufficient) #but this is not solved yet, see https://github.com/proycon/folia/issues/19 #elements.append( E.data(E.param(r".+",name="pattern"),type='string')) #elements.append( E.data(E.param(r"(.|\n|\r)*\S+(.|\n|\r)*",name="pattern"),type='string')) done = {} if includechildren and cls.ACCEPTED_DATA: #pylint: disable=too-many-nested-blocks for c in cls.ACCEPTED_DATA: if c.__name__[:8] == 'Abstract' and inspect.isclass(c): for c2 in globals().values(): try: if inspect.isclass(c2) and issubclass(c2, c): try: if c2.XMLTAG and c2.XMLTAG not in done: if c2.OCCURRENCES == 1: elements.append( E.optional( E.ref(name=c2.XMLTAG) ) ) else: elements.append( E.zeroOrMore( E.ref(name=c2.XMLTAG) ) ) if c2.XMLTAG == 'item': #nasty hack for backward compatibility with deprecated listitem element elements.append( E.zeroOrMore( E.ref(name='listitem') ) ) done[c2.XMLTAG] = True except AttributeError: continue except TypeError: pass elif issubclass(c, Feature) and c.SUBSET: attribs.append( E.optional( E.attribute(name=c.SUBSET))) #features as attributes else: try: if c.XMLTAG and c.XMLTAG not in done: if cls.REQUIRED_DATA and c in cls.REQUIRED_DATA: if c.OCCURRENCES == 1: elements.append( E.ref(name=c.XMLTAG) ) else: elements.append( E.oneOrMore( E.ref(name=c.XMLTAG) ) ) elif c.OCCURRENCES == 1: elements.append( E.optional( E.ref(name=c.XMLTAG) ) ) else: elements.append( E.zeroOrMore( E.ref(name=c.XMLTAG) ) ) if c.XMLTAG == 'item': #nasty hack for backward compatibility with deprecated listitem element elements.append( E.zeroOrMore( E.ref(name='listitem') ) ) done[c.XMLTAG] = True except AttributeError: continue if extraelements: for e in extraelements: elements.append( e ) if elements: if len(elements) > 1: attribs.append( E.interleave(*elements) ) else: attribs.append( *elements ) if not attribs: attribs.append( E.empty() ) if cls.XMLTAG in ('desc','comment'): return E.define( E.element(E.text(), *(preamble + attribs), **{'name': cls.XMLTAG}), name=cls.XMLTAG, ns=NSFOLIA) else: return E.define( E.element(*(preamble + attribs), **{'name': cls.XMLTAG}), name=cls.XMLTAG, ns=NSFOLIA)
python
def relaxng(cls, includechildren=True,extraattribs = None, extraelements=None, origclass = None): """Returns a RelaxNG definition for this element (as an XML element (lxml.etree) rather than a string)""" E = ElementMaker(namespace="http://relaxng.org/ns/structure/1.0",nsmap={None:'http://relaxng.org/ns/structure/1.0' , 'folia': "http://ilk.uvt.nl/folia", 'xml' : "http://www.w3.org/XML/1998/namespace",'a':"http://relaxng.org/ns/annotation/0.9" }) if origclass: cls = origclass preamble = [] try: if cls.__doc__: E2 = ElementMaker(namespace="http://relaxng.org/ns/annotation/0.9", nsmap={'a':'http://relaxng.org/ns/annotation/0.9'} ) preamble.append(E2.documentation(cls.__doc__)) except AttributeError: pass if cls.REQUIRED_ATTRIBS is None: cls.REQUIRED_ATTRIBS = () #bit hacky if cls.OPTIONAL_ATTRIBS is None: cls.OPTIONAL_ATTRIBS = () #bit hacky attribs = [ ] if cls.REQUIRED_ATTRIBS and Attrib.ID in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute(E.data(type='ID',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='id', ns="http://www.w3.org/XML/1998/namespace") ) elif Attrib.ID in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='ID',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='id', ns="http://www.w3.org/XML/1998/namespace") ) ) if Attrib.CLASS in cls.REQUIRED_ATTRIBS: #Set is a tough one, we can't require it as it may be defined in the declaration: we make it optional and need schematron to resolve this later attribs.append( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='class') ) attribs.append( E.optional( E.attribute( E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='set' ) ) ) elif Attrib.CLASS in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='class') ) ) attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='set' ) ) ) if Attrib.ANNOTATOR in cls.REQUIRED_ATTRIBS or Attrib.ANNOTATOR in cls.OPTIONAL_ATTRIBS: #Similarly tough attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='annotator') ) ) attribs.append( E.optional( E.attribute(name='annotatortype') ) ) if Attrib.CONFIDENCE in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute(E.data(type='double',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='confidence') ) elif Attrib.CONFIDENCE in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='double',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='confidence') ) ) if Attrib.N in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute( E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='n') ) elif Attrib.N in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute( E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='n') ) ) if Attrib.DATETIME in cls.REQUIRED_ATTRIBS: attribs.append( E.attribute(E.data(type='dateTime',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='datetime') ) elif Attrib.DATETIME in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute( E.data(type='dateTime',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='datetime') ) ) if Attrib.BEGINTIME in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='begintime') ) elif Attrib.BEGINTIME in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='begintime') ) ) if Attrib.ENDTIME in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='endtime') ) elif Attrib.ENDTIME in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='endtime') ) ) if Attrib.SRC in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(E.data(type='anyURI',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='src') ) elif Attrib.SRC in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='anyURI',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='src') ) ) if Attrib.SPEAKER in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'), name='speaker') ) elif Attrib.SPEAKER in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(E.data(type='string',datatypeLibrary='http://www.w3.org/2001/XMLSchema-datatypes'),name='speaker') ) ) if Attrib.TEXTCLASS in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='textclass') ) elif Attrib.TEXTCLASS in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='textclass') ) ) if Attrib.METADATA in cls.REQUIRED_ATTRIBS: attribs.append(E.attribute(name='metadata') ) elif Attrib.METADATA in cls.OPTIONAL_ATTRIBS: attribs.append( E.optional( E.attribute(name='metadata') ) ) if cls.XLINK: attribs += [ #loose interpretation of specs, not checking whether xlink combinations are valid E.optional(E.attribute(name='href',ns="http://www.w3.org/1999/xlink"),E.attribute(name='type',ns="http://www.w3.org/1999/xlink") ), E.optional(E.attribute(name='role',ns="http://www.w3.org/1999/xlink")), E.optional(E.attribute(name='title',ns="http://www.w3.org/1999/xlink")), E.optional(E.attribute(name='label',ns="http://www.w3.org/1999/xlink")), E.optional(E.attribute(name='show',ns="http://www.w3.org/1999/xlink")), ] attribs.append( E.optional( E.attribute( name='auth' ) ) ) if extraattribs: for e in extraattribs: attribs.append(e) #s attribs.append( E.ref(name="allow_foreign_attributes") ) elements = [] #(including attributes) if cls.TEXTCONTAINER or cls.PHONCONTAINER: elements.append( E.text()) #We actually want to require non-empty text (E.text() is not sufficient) #but this is not solved yet, see https://github.com/proycon/folia/issues/19 #elements.append( E.data(E.param(r".+",name="pattern"),type='string')) #elements.append( E.data(E.param(r"(.|\n|\r)*\S+(.|\n|\r)*",name="pattern"),type='string')) done = {} if includechildren and cls.ACCEPTED_DATA: #pylint: disable=too-many-nested-blocks for c in cls.ACCEPTED_DATA: if c.__name__[:8] == 'Abstract' and inspect.isclass(c): for c2 in globals().values(): try: if inspect.isclass(c2) and issubclass(c2, c): try: if c2.XMLTAG and c2.XMLTAG not in done: if c2.OCCURRENCES == 1: elements.append( E.optional( E.ref(name=c2.XMLTAG) ) ) else: elements.append( E.zeroOrMore( E.ref(name=c2.XMLTAG) ) ) if c2.XMLTAG == 'item': #nasty hack for backward compatibility with deprecated listitem element elements.append( E.zeroOrMore( E.ref(name='listitem') ) ) done[c2.XMLTAG] = True except AttributeError: continue except TypeError: pass elif issubclass(c, Feature) and c.SUBSET: attribs.append( E.optional( E.attribute(name=c.SUBSET))) #features as attributes else: try: if c.XMLTAG and c.XMLTAG not in done: if cls.REQUIRED_DATA and c in cls.REQUIRED_DATA: if c.OCCURRENCES == 1: elements.append( E.ref(name=c.XMLTAG) ) else: elements.append( E.oneOrMore( E.ref(name=c.XMLTAG) ) ) elif c.OCCURRENCES == 1: elements.append( E.optional( E.ref(name=c.XMLTAG) ) ) else: elements.append( E.zeroOrMore( E.ref(name=c.XMLTAG) ) ) if c.XMLTAG == 'item': #nasty hack for backward compatibility with deprecated listitem element elements.append( E.zeroOrMore( E.ref(name='listitem') ) ) done[c.XMLTAG] = True except AttributeError: continue if extraelements: for e in extraelements: elements.append( e ) if elements: if len(elements) > 1: attribs.append( E.interleave(*elements) ) else: attribs.append( *elements ) if not attribs: attribs.append( E.empty() ) if cls.XMLTAG in ('desc','comment'): return E.define( E.element(E.text(), *(preamble + attribs), **{'name': cls.XMLTAG}), name=cls.XMLTAG, ns=NSFOLIA) else: return E.define( E.element(*(preamble + attribs), **{'name': cls.XMLTAG}), name=cls.XMLTAG, ns=NSFOLIA)
[ "def", "relaxng", "(", "cls", ",", "includechildren", "=", "True", ",", "extraattribs", "=", "None", ",", "extraelements", "=", "None", ",", "origclass", "=", "None", ")", ":", "E", "=", "ElementMaker", "(", "namespace", "=", "\"http://relaxng.org/ns/structure/1.0\"", ",", "nsmap", "=", "{", "None", ":", "'http://relaxng.org/ns/structure/1.0'", ",", "'folia'", ":", "\"http://ilk.uvt.nl/folia\"", ",", "'xml'", ":", "\"http://www.w3.org/XML/1998/namespace\"", ",", "'a'", ":", "\"http://relaxng.org/ns/annotation/0.9\"", "}", ")", "if", "origclass", ":", "cls", "=", "origclass", "preamble", "=", "[", "]", "try", ":", "if", "cls", ".", "__doc__", ":", "E2", "=", "ElementMaker", "(", "namespace", "=", "\"http://relaxng.org/ns/annotation/0.9\"", ",", "nsmap", "=", "{", "'a'", ":", "'http://relaxng.org/ns/annotation/0.9'", "}", ")", "preamble", ".", "append", "(", "E2", ".", "documentation", "(", "cls", ".", "__doc__", ")", ")", "except", "AttributeError", ":", "pass", "if", "cls", ".", "REQUIRED_ATTRIBS", "is", "None", ":", "cls", ".", "REQUIRED_ATTRIBS", "=", "(", ")", "#bit hacky", "if", "cls", ".", "OPTIONAL_ATTRIBS", "is", "None", ":", "cls", ".", "OPTIONAL_ATTRIBS", "=", "(", ")", "#bit hacky", "attribs", "=", "[", "]", "if", "cls", ".", "REQUIRED_ATTRIBS", "and", "Attrib", ".", "ID", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'ID'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'id'", ",", "ns", "=", "\"http://www.w3.org/XML/1998/namespace\"", ")", ")", "elif", "Attrib", ".", "ID", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'ID'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'id'", ",", "ns", "=", "\"http://www.w3.org/XML/1998/namespace\"", ")", ")", ")", "if", "Attrib", ".", "CLASS", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "#Set is a tough one, we can't require it as it may be defined in the declaration: we make it optional and need schematron to resolve this later", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'class'", ")", ")", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'set'", ")", ")", ")", "elif", "Attrib", ".", "CLASS", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'class'", ")", ")", ")", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'set'", ")", ")", ")", "if", "Attrib", ".", "ANNOTATOR", "in", "cls", ".", "REQUIRED_ATTRIBS", "or", "Attrib", ".", "ANNOTATOR", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "#Similarly tough", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'annotator'", ")", ")", ")", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'annotatortype'", ")", ")", ")", "if", "Attrib", ".", "CONFIDENCE", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'double'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'confidence'", ")", ")", "elif", "Attrib", ".", "CONFIDENCE", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'double'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'confidence'", ")", ")", ")", "if", "Attrib", ".", "N", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'n'", ")", ")", "elif", "Attrib", ".", "N", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'n'", ")", ")", ")", "if", "Attrib", ".", "DATETIME", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'dateTime'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'datetime'", ")", ")", "elif", "Attrib", ".", "DATETIME", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'dateTime'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'datetime'", ")", ")", ")", "if", "Attrib", ".", "BEGINTIME", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "name", "=", "'begintime'", ")", ")", "elif", "Attrib", ".", "BEGINTIME", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'begintime'", ")", ")", ")", "if", "Attrib", ".", "ENDTIME", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "name", "=", "'endtime'", ")", ")", "elif", "Attrib", ".", "ENDTIME", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'endtime'", ")", ")", ")", "if", "Attrib", ".", "SRC", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'anyURI'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'src'", ")", ")", "elif", "Attrib", ".", "SRC", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'anyURI'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'src'", ")", ")", ")", "if", "Attrib", ".", "SPEAKER", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'speaker'", ")", ")", "elif", "Attrib", ".", "SPEAKER", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "data", "(", "type", "=", "'string'", ",", "datatypeLibrary", "=", "'http://www.w3.org/2001/XMLSchema-datatypes'", ")", ",", "name", "=", "'speaker'", ")", ")", ")", "if", "Attrib", ".", "TEXTCLASS", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "name", "=", "'textclass'", ")", ")", "elif", "Attrib", ".", "TEXTCLASS", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'textclass'", ")", ")", ")", "if", "Attrib", ".", "METADATA", "in", "cls", ".", "REQUIRED_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "attribute", "(", "name", "=", "'metadata'", ")", ")", "elif", "Attrib", ".", "METADATA", "in", "cls", ".", "OPTIONAL_ATTRIBS", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'metadata'", ")", ")", ")", "if", "cls", ".", "XLINK", ":", "attribs", "+=", "[", "#loose interpretation of specs, not checking whether xlink combinations are valid", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'href'", ",", "ns", "=", "\"http://www.w3.org/1999/xlink\"", ")", ",", "E", ".", "attribute", "(", "name", "=", "'type'", ",", "ns", "=", "\"http://www.w3.org/1999/xlink\"", ")", ")", ",", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'role'", ",", "ns", "=", "\"http://www.w3.org/1999/xlink\"", ")", ")", ",", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'title'", ",", "ns", "=", "\"http://www.w3.org/1999/xlink\"", ")", ")", ",", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'label'", ",", "ns", "=", "\"http://www.w3.org/1999/xlink\"", ")", ")", ",", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'show'", ",", "ns", "=", "\"http://www.w3.org/1999/xlink\"", ")", ")", ",", "]", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "'auth'", ")", ")", ")", "if", "extraattribs", ":", "for", "e", "in", "extraattribs", ":", "attribs", ".", "append", "(", "e", ")", "#s", "attribs", ".", "append", "(", "E", ".", "ref", "(", "name", "=", "\"allow_foreign_attributes\"", ")", ")", "elements", "=", "[", "]", "#(including attributes)", "if", "cls", ".", "TEXTCONTAINER", "or", "cls", ".", "PHONCONTAINER", ":", "elements", ".", "append", "(", "E", ".", "text", "(", ")", ")", "#We actually want to require non-empty text (E.text() is not sufficient)", "#but this is not solved yet, see https://github.com/proycon/folia/issues/19", "#elements.append( E.data(E.param(r\".+\",name=\"pattern\"),type='string'))", "#elements.append( E.data(E.param(r\"(.|\\n|\\r)*\\S+(.|\\n|\\r)*\",name=\"pattern\"),type='string'))", "done", "=", "{", "}", "if", "includechildren", "and", "cls", ".", "ACCEPTED_DATA", ":", "#pylint: disable=too-many-nested-blocks", "for", "c", "in", "cls", ".", "ACCEPTED_DATA", ":", "if", "c", ".", "__name__", "[", ":", "8", "]", "==", "'Abstract'", "and", "inspect", ".", "isclass", "(", "c", ")", ":", "for", "c2", "in", "globals", "(", ")", ".", "values", "(", ")", ":", "try", ":", "if", "inspect", ".", "isclass", "(", "c2", ")", "and", "issubclass", "(", "c2", ",", "c", ")", ":", "try", ":", "if", "c2", ".", "XMLTAG", "and", "c2", ".", "XMLTAG", "not", "in", "done", ":", "if", "c2", ".", "OCCURRENCES", "==", "1", ":", "elements", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "ref", "(", "name", "=", "c2", ".", "XMLTAG", ")", ")", ")", "else", ":", "elements", ".", "append", "(", "E", ".", "zeroOrMore", "(", "E", ".", "ref", "(", "name", "=", "c2", ".", "XMLTAG", ")", ")", ")", "if", "c2", ".", "XMLTAG", "==", "'item'", ":", "#nasty hack for backward compatibility with deprecated listitem element", "elements", ".", "append", "(", "E", ".", "zeroOrMore", "(", "E", ".", "ref", "(", "name", "=", "'listitem'", ")", ")", ")", "done", "[", "c2", ".", "XMLTAG", "]", "=", "True", "except", "AttributeError", ":", "continue", "except", "TypeError", ":", "pass", "elif", "issubclass", "(", "c", ",", "Feature", ")", "and", "c", ".", "SUBSET", ":", "attribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "name", "=", "c", ".", "SUBSET", ")", ")", ")", "#features as attributes", "else", ":", "try", ":", "if", "c", ".", "XMLTAG", "and", "c", ".", "XMLTAG", "not", "in", "done", ":", "if", "cls", ".", "REQUIRED_DATA", "and", "c", "in", "cls", ".", "REQUIRED_DATA", ":", "if", "c", ".", "OCCURRENCES", "==", "1", ":", "elements", ".", "append", "(", "E", ".", "ref", "(", "name", "=", "c", ".", "XMLTAG", ")", ")", "else", ":", "elements", ".", "append", "(", "E", ".", "oneOrMore", "(", "E", ".", "ref", "(", "name", "=", "c", ".", "XMLTAG", ")", ")", ")", "elif", "c", ".", "OCCURRENCES", "==", "1", ":", "elements", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "ref", "(", "name", "=", "c", ".", "XMLTAG", ")", ")", ")", "else", ":", "elements", ".", "append", "(", "E", ".", "zeroOrMore", "(", "E", ".", "ref", "(", "name", "=", "c", ".", "XMLTAG", ")", ")", ")", "if", "c", ".", "XMLTAG", "==", "'item'", ":", "#nasty hack for backward compatibility with deprecated listitem element", "elements", ".", "append", "(", "E", ".", "zeroOrMore", "(", "E", ".", "ref", "(", "name", "=", "'listitem'", ")", ")", ")", "done", "[", "c", ".", "XMLTAG", "]", "=", "True", "except", "AttributeError", ":", "continue", "if", "extraelements", ":", "for", "e", "in", "extraelements", ":", "elements", ".", "append", "(", "e", ")", "if", "elements", ":", "if", "len", "(", "elements", ")", ">", "1", ":", "attribs", ".", "append", "(", "E", ".", "interleave", "(", "*", "elements", ")", ")", "else", ":", "attribs", ".", "append", "(", "*", "elements", ")", "if", "not", "attribs", ":", "attribs", ".", "append", "(", "E", ".", "empty", "(", ")", ")", "if", "cls", ".", "XMLTAG", "in", "(", "'desc'", ",", "'comment'", ")", ":", "return", "E", ".", "define", "(", "E", ".", "element", "(", "E", ".", "text", "(", ")", ",", "*", "(", "preamble", "+", "attribs", ")", ",", "*", "*", "{", "'name'", ":", "cls", ".", "XMLTAG", "}", ")", ",", "name", "=", "cls", ".", "XMLTAG", ",", "ns", "=", "NSFOLIA", ")", "else", ":", "return", "E", ".", "define", "(", "E", ".", "element", "(", "*", "(", "preamble", "+", "attribs", ")", ",", "*", "*", "{", "'name'", ":", "cls", ".", "XMLTAG", "}", ")", ",", "name", "=", "cls", ".", "XMLTAG", ",", "ns", "=", "NSFOLIA", ")" ]
Returns a RelaxNG definition for this element (as an XML element (lxml.etree) rather than a string)
[ "Returns", "a", "RelaxNG", "definition", "for", "this", "element", "(", "as", "an", "XML", "element", "(", "lxml", ".", "etree", ")", "rather", "than", "a", "string", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2424-L2579
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.parsexml
def parsexml(Class, node, doc, **kwargs): #pylint: disable=bad-classmethod-argument """Internal class method used for turning an XML element into an instance of the Class. Args: * ``node`` - XML Element * ``doc`` - Document Returns: An instance of the current Class. """ assert issubclass(Class, AbstractElement) if doc.preparsexmlcallback: result = doc.preparsexmlcallback(node) if not result: return None if isinstance(result, AbstractElement): return result dcoi = node.tag.startswith('{' + NSDCOI + '}') args = [] if not kwargs: kwargs = {} text = None #for dcoi support if (Class.TEXTCONTAINER or Class.PHONCONTAINER) and node.text: args.append(node.text) for subnode in node: #pylint: disable=too-many-nested-blocks #don't trip over comments if isinstance(subnode, ElementTree._Comment): #pylint: disable=protected-access if (Class.TEXTCONTAINER or Class.PHONCONTAINER) and subnode.tail: args.append(subnode.tail) else: if subnode.tag.startswith('{' + NSFOLIA + '}'): if doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Processing subnode " + subnode.tag[nslen:],file=stderr) try: e = doc.parsexml(subnode, Class) except ParseError as e: raise #just re-raise deepest parseError except Exception as e: #Python 3 will preserve full original traceback, Python 2 does not, original cause is explicitly passed to ParseError anyway: raise ParseError("FoLiA exception in handling of <" + subnode.tag[len(NSFOLIA)+2:] + "> @ line " + str(subnode.sourceline) + ": [" + e.__class__.__name__ + "] " + str(e), cause=e) if e is not None: args.append(e) if (Class.TEXTCONTAINER or Class.PHONCONTAINER) and subnode.tail: args.append(subnode.tail) elif subnode.tag.startswith('{' + NSDCOI + '}'): #Dcoi support if Class is Text and subnode.tag[nslendcoi:] == 'body': for subsubnode in subnode: if doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Processing DCOI subnode " + subnode.tag[nslendcoi:],file=stderr) e = doc.parsexml(subsubnode, Class) if e is not None: args.append(e) else: if doc.debug >= 1: print( "[PyNLPl FoLiA DEBUG] Processing DCOI subnode " + subnode.tag[nslendcoi:],file=stderr) e = doc.parsexml(subnode, Class) if e is not None: args.append(e) elif doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Ignoring subnode outside of FoLiA namespace: " + subnode.tag,file=stderr) if dcoi: dcoipos = dcoilemma = dcoicorrection = dcoicorrectionoriginal = None for key, value in node.attrib.items(): if key[0] == '{' or key =='XMLid': if key == '{http://www.w3.org/XML/1998/namespace}id' or key == 'XMLid': key = 'id' elif key.startswith( '{' + NSFOLIA + '}'): key = key[nslen:] if key == 'id': #ID in FoLiA namespace is always a reference, passed in kwargs as follows: key = 'idref' elif Class.XLINK and key.startswith('{http://www.w3.org/1999/xlink}'): key = key[30:] if key != 'href': key = 'xlink' + key #xlinktype, xlinkrole, xlinklabel, xlinkshow, etc.. elif key.startswith('{' + NSDCOI + '}'): key = key[nslendcoi:] #D-Coi support: if dcoi: if Class is Word and key == 'pos': dcoipos = value continue elif Class is Word and key == 'lemma': dcoilemma = value continue elif Class is Word and key == 'correction': dcoicorrection = value #class continue elif Class is Word and key == 'original': dcoicorrectionoriginal = value continue elif Class is Gap and key == 'reason': key = 'class' elif Class is Gap and key == 'hand': key = 'annotator' elif Class is Division and key == 'type': key = 'cls' kwargs[key] = value #D-Coi support: if dcoi and TextContent in Class.ACCEPTED_DATA and node.text: text = node.text.strip() kwargs['text'] = text if not AnnotationType.TOKEN in doc.annotationdefaults: doc.declare(AnnotationType.TOKEN, set='http://ilk.uvt.nl/folia/sets/ilktok.foliaset') if doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Found " + node.tag[nslen:],file=stderr) instance = Class(doc, *args, **kwargs) #if id: # if doc.debug >= 1: print >>stderr, "[PyNLPl FoLiA DEBUG] Adding to index: " + id # doc.index[id] = instance if dcoi: if dcoipos: if not AnnotationType.POS in doc.annotationdefaults: doc.declare(AnnotationType.POS, set='http://ilk.uvt.nl/folia/sets/cgn-legacy.foliaset') instance.append( PosAnnotation(doc, cls=dcoipos) ) if dcoilemma: if not AnnotationType.LEMMA in doc.annotationdefaults: doc.declare(AnnotationType.LEMMA, set='http://ilk.uvt.nl/folia/sets/mblem-nl.foliaset') instance.append( LemmaAnnotation(doc, cls=dcoilemma) ) if dcoicorrection and dcoicorrectionoriginal and text: if not AnnotationType.CORRECTION in doc.annotationdefaults: doc.declare(AnnotationType.CORRECTION, set='http://ilk.uvt.nl/folia/sets/dcoi-corrections.foliaset') instance.correct(generate_id_in=instance, cls=dcoicorrection, original=dcoicorrectionoriginal, new=text) if doc.parsexmlcallback: result = doc.parsexmlcallback(instance) if not result: return None if isinstance(result, AbstractElement): return result return instance
python
def parsexml(Class, node, doc, **kwargs): #pylint: disable=bad-classmethod-argument """Internal class method used for turning an XML element into an instance of the Class. Args: * ``node`` - XML Element * ``doc`` - Document Returns: An instance of the current Class. """ assert issubclass(Class, AbstractElement) if doc.preparsexmlcallback: result = doc.preparsexmlcallback(node) if not result: return None if isinstance(result, AbstractElement): return result dcoi = node.tag.startswith('{' + NSDCOI + '}') args = [] if not kwargs: kwargs = {} text = None #for dcoi support if (Class.TEXTCONTAINER or Class.PHONCONTAINER) and node.text: args.append(node.text) for subnode in node: #pylint: disable=too-many-nested-blocks #don't trip over comments if isinstance(subnode, ElementTree._Comment): #pylint: disable=protected-access if (Class.TEXTCONTAINER or Class.PHONCONTAINER) and subnode.tail: args.append(subnode.tail) else: if subnode.tag.startswith('{' + NSFOLIA + '}'): if doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Processing subnode " + subnode.tag[nslen:],file=stderr) try: e = doc.parsexml(subnode, Class) except ParseError as e: raise #just re-raise deepest parseError except Exception as e: #Python 3 will preserve full original traceback, Python 2 does not, original cause is explicitly passed to ParseError anyway: raise ParseError("FoLiA exception in handling of <" + subnode.tag[len(NSFOLIA)+2:] + "> @ line " + str(subnode.sourceline) + ": [" + e.__class__.__name__ + "] " + str(e), cause=e) if e is not None: args.append(e) if (Class.TEXTCONTAINER or Class.PHONCONTAINER) and subnode.tail: args.append(subnode.tail) elif subnode.tag.startswith('{' + NSDCOI + '}'): #Dcoi support if Class is Text and subnode.tag[nslendcoi:] == 'body': for subsubnode in subnode: if doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Processing DCOI subnode " + subnode.tag[nslendcoi:],file=stderr) e = doc.parsexml(subsubnode, Class) if e is not None: args.append(e) else: if doc.debug >= 1: print( "[PyNLPl FoLiA DEBUG] Processing DCOI subnode " + subnode.tag[nslendcoi:],file=stderr) e = doc.parsexml(subnode, Class) if e is not None: args.append(e) elif doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Ignoring subnode outside of FoLiA namespace: " + subnode.tag,file=stderr) if dcoi: dcoipos = dcoilemma = dcoicorrection = dcoicorrectionoriginal = None for key, value in node.attrib.items(): if key[0] == '{' or key =='XMLid': if key == '{http://www.w3.org/XML/1998/namespace}id' or key == 'XMLid': key = 'id' elif key.startswith( '{' + NSFOLIA + '}'): key = key[nslen:] if key == 'id': #ID in FoLiA namespace is always a reference, passed in kwargs as follows: key = 'idref' elif Class.XLINK and key.startswith('{http://www.w3.org/1999/xlink}'): key = key[30:] if key != 'href': key = 'xlink' + key #xlinktype, xlinkrole, xlinklabel, xlinkshow, etc.. elif key.startswith('{' + NSDCOI + '}'): key = key[nslendcoi:] #D-Coi support: if dcoi: if Class is Word and key == 'pos': dcoipos = value continue elif Class is Word and key == 'lemma': dcoilemma = value continue elif Class is Word and key == 'correction': dcoicorrection = value #class continue elif Class is Word and key == 'original': dcoicorrectionoriginal = value continue elif Class is Gap and key == 'reason': key = 'class' elif Class is Gap and key == 'hand': key = 'annotator' elif Class is Division and key == 'type': key = 'cls' kwargs[key] = value #D-Coi support: if dcoi and TextContent in Class.ACCEPTED_DATA and node.text: text = node.text.strip() kwargs['text'] = text if not AnnotationType.TOKEN in doc.annotationdefaults: doc.declare(AnnotationType.TOKEN, set='http://ilk.uvt.nl/folia/sets/ilktok.foliaset') if doc.debug >= 1: print("[PyNLPl FoLiA DEBUG] Found " + node.tag[nslen:],file=stderr) instance = Class(doc, *args, **kwargs) #if id: # if doc.debug >= 1: print >>stderr, "[PyNLPl FoLiA DEBUG] Adding to index: " + id # doc.index[id] = instance if dcoi: if dcoipos: if not AnnotationType.POS in doc.annotationdefaults: doc.declare(AnnotationType.POS, set='http://ilk.uvt.nl/folia/sets/cgn-legacy.foliaset') instance.append( PosAnnotation(doc, cls=dcoipos) ) if dcoilemma: if not AnnotationType.LEMMA in doc.annotationdefaults: doc.declare(AnnotationType.LEMMA, set='http://ilk.uvt.nl/folia/sets/mblem-nl.foliaset') instance.append( LemmaAnnotation(doc, cls=dcoilemma) ) if dcoicorrection and dcoicorrectionoriginal and text: if not AnnotationType.CORRECTION in doc.annotationdefaults: doc.declare(AnnotationType.CORRECTION, set='http://ilk.uvt.nl/folia/sets/dcoi-corrections.foliaset') instance.correct(generate_id_in=instance, cls=dcoicorrection, original=dcoicorrectionoriginal, new=text) if doc.parsexmlcallback: result = doc.parsexmlcallback(instance) if not result: return None if isinstance(result, AbstractElement): return result return instance
[ "def", "parsexml", "(", "Class", ",", "node", ",", "doc", ",", "*", "*", "kwargs", ")", ":", "#pylint: disable=bad-classmethod-argument", "assert", "issubclass", "(", "Class", ",", "AbstractElement", ")", "if", "doc", ".", "preparsexmlcallback", ":", "result", "=", "doc", ".", "preparsexmlcallback", "(", "node", ")", "if", "not", "result", ":", "return", "None", "if", "isinstance", "(", "result", ",", "AbstractElement", ")", ":", "return", "result", "dcoi", "=", "node", ".", "tag", ".", "startswith", "(", "'{'", "+", "NSDCOI", "+", "'}'", ")", "args", "=", "[", "]", "if", "not", "kwargs", ":", "kwargs", "=", "{", "}", "text", "=", "None", "#for dcoi support", "if", "(", "Class", ".", "TEXTCONTAINER", "or", "Class", ".", "PHONCONTAINER", ")", "and", "node", ".", "text", ":", "args", ".", "append", "(", "node", ".", "text", ")", "for", "subnode", "in", "node", ":", "#pylint: disable=too-many-nested-blocks", "#don't trip over comments", "if", "isinstance", "(", "subnode", ",", "ElementTree", ".", "_Comment", ")", ":", "#pylint: disable=protected-access", "if", "(", "Class", ".", "TEXTCONTAINER", "or", "Class", ".", "PHONCONTAINER", ")", "and", "subnode", ".", "tail", ":", "args", ".", "append", "(", "subnode", ".", "tail", ")", "else", ":", "if", "subnode", ".", "tag", ".", "startswith", "(", "'{'", "+", "NSFOLIA", "+", "'}'", ")", ":", "if", "doc", ".", "debug", ">=", "1", ":", "print", "(", "\"[PyNLPl FoLiA DEBUG] Processing subnode \"", "+", "subnode", ".", "tag", "[", "nslen", ":", "]", ",", "file", "=", "stderr", ")", "try", ":", "e", "=", "doc", ".", "parsexml", "(", "subnode", ",", "Class", ")", "except", "ParseError", "as", "e", ":", "raise", "#just re-raise deepest parseError", "except", "Exception", "as", "e", ":", "#Python 3 will preserve full original traceback, Python 2 does not, original cause is explicitly passed to ParseError anyway:", "raise", "ParseError", "(", "\"FoLiA exception in handling of <\"", "+", "subnode", ".", "tag", "[", "len", "(", "NSFOLIA", ")", "+", "2", ":", "]", "+", "\"> @ line \"", "+", "str", "(", "subnode", ".", "sourceline", ")", "+", "\": [\"", "+", "e", ".", "__class__", ".", "__name__", "+", "\"] \"", "+", "str", "(", "e", ")", ",", "cause", "=", "e", ")", "if", "e", "is", "not", "None", ":", "args", ".", "append", "(", "e", ")", "if", "(", "Class", ".", "TEXTCONTAINER", "or", "Class", ".", "PHONCONTAINER", ")", "and", "subnode", ".", "tail", ":", "args", ".", "append", "(", "subnode", ".", "tail", ")", "elif", "subnode", ".", "tag", ".", "startswith", "(", "'{'", "+", "NSDCOI", "+", "'}'", ")", ":", "#Dcoi support", "if", "Class", "is", "Text", "and", "subnode", ".", "tag", "[", "nslendcoi", ":", "]", "==", "'body'", ":", "for", "subsubnode", "in", "subnode", ":", "if", "doc", ".", "debug", ">=", "1", ":", "print", "(", "\"[PyNLPl FoLiA DEBUG] Processing DCOI subnode \"", "+", "subnode", ".", "tag", "[", "nslendcoi", ":", "]", ",", "file", "=", "stderr", ")", "e", "=", "doc", ".", "parsexml", "(", "subsubnode", ",", "Class", ")", "if", "e", "is", "not", "None", ":", "args", ".", "append", "(", "e", ")", "else", ":", "if", "doc", ".", "debug", ">=", "1", ":", "print", "(", "\"[PyNLPl FoLiA DEBUG] Processing DCOI subnode \"", "+", "subnode", ".", "tag", "[", "nslendcoi", ":", "]", ",", "file", "=", "stderr", ")", "e", "=", "doc", ".", "parsexml", "(", "subnode", ",", "Class", ")", "if", "e", "is", "not", "None", ":", "args", ".", "append", "(", "e", ")", "elif", "doc", ".", "debug", ">=", "1", ":", "print", "(", "\"[PyNLPl FoLiA DEBUG] Ignoring subnode outside of FoLiA namespace: \"", "+", "subnode", ".", "tag", ",", "file", "=", "stderr", ")", "if", "dcoi", ":", "dcoipos", "=", "dcoilemma", "=", "dcoicorrection", "=", "dcoicorrectionoriginal", "=", "None", "for", "key", ",", "value", "in", "node", ".", "attrib", ".", "items", "(", ")", ":", "if", "key", "[", "0", "]", "==", "'{'", "or", "key", "==", "'XMLid'", ":", "if", "key", "==", "'{http://www.w3.org/XML/1998/namespace}id'", "or", "key", "==", "'XMLid'", ":", "key", "=", "'id'", "elif", "key", ".", "startswith", "(", "'{'", "+", "NSFOLIA", "+", "'}'", ")", ":", "key", "=", "key", "[", "nslen", ":", "]", "if", "key", "==", "'id'", ":", "#ID in FoLiA namespace is always a reference, passed in kwargs as follows:", "key", "=", "'idref'", "elif", "Class", ".", "XLINK", "and", "key", ".", "startswith", "(", "'{http://www.w3.org/1999/xlink}'", ")", ":", "key", "=", "key", "[", "30", ":", "]", "if", "key", "!=", "'href'", ":", "key", "=", "'xlink'", "+", "key", "#xlinktype, xlinkrole, xlinklabel, xlinkshow, etc..", "elif", "key", ".", "startswith", "(", "'{'", "+", "NSDCOI", "+", "'}'", ")", ":", "key", "=", "key", "[", "nslendcoi", ":", "]", "#D-Coi support:", "if", "dcoi", ":", "if", "Class", "is", "Word", "and", "key", "==", "'pos'", ":", "dcoipos", "=", "value", "continue", "elif", "Class", "is", "Word", "and", "key", "==", "'lemma'", ":", "dcoilemma", "=", "value", "continue", "elif", "Class", "is", "Word", "and", "key", "==", "'correction'", ":", "dcoicorrection", "=", "value", "#class", "continue", "elif", "Class", "is", "Word", "and", "key", "==", "'original'", ":", "dcoicorrectionoriginal", "=", "value", "continue", "elif", "Class", "is", "Gap", "and", "key", "==", "'reason'", ":", "key", "=", "'class'", "elif", "Class", "is", "Gap", "and", "key", "==", "'hand'", ":", "key", "=", "'annotator'", "elif", "Class", "is", "Division", "and", "key", "==", "'type'", ":", "key", "=", "'cls'", "kwargs", "[", "key", "]", "=", "value", "#D-Coi support:", "if", "dcoi", "and", "TextContent", "in", "Class", ".", "ACCEPTED_DATA", "and", "node", ".", "text", ":", "text", "=", "node", ".", "text", ".", "strip", "(", ")", "kwargs", "[", "'text'", "]", "=", "text", "if", "not", "AnnotationType", ".", "TOKEN", "in", "doc", ".", "annotationdefaults", ":", "doc", ".", "declare", "(", "AnnotationType", ".", "TOKEN", ",", "set", "=", "'http://ilk.uvt.nl/folia/sets/ilktok.foliaset'", ")", "if", "doc", ".", "debug", ">=", "1", ":", "print", "(", "\"[PyNLPl FoLiA DEBUG] Found \"", "+", "node", ".", "tag", "[", "nslen", ":", "]", ",", "file", "=", "stderr", ")", "instance", "=", "Class", "(", "doc", ",", "*", "args", ",", "*", "*", "kwargs", ")", "#if id:", "# if doc.debug >= 1: print >>stderr, \"[PyNLPl FoLiA DEBUG] Adding to index: \" + id", "# doc.index[id] = instance", "if", "dcoi", ":", "if", "dcoipos", ":", "if", "not", "AnnotationType", ".", "POS", "in", "doc", ".", "annotationdefaults", ":", "doc", ".", "declare", "(", "AnnotationType", ".", "POS", ",", "set", "=", "'http://ilk.uvt.nl/folia/sets/cgn-legacy.foliaset'", ")", "instance", ".", "append", "(", "PosAnnotation", "(", "doc", ",", "cls", "=", "dcoipos", ")", ")", "if", "dcoilemma", ":", "if", "not", "AnnotationType", ".", "LEMMA", "in", "doc", ".", "annotationdefaults", ":", "doc", ".", "declare", "(", "AnnotationType", ".", "LEMMA", ",", "set", "=", "'http://ilk.uvt.nl/folia/sets/mblem-nl.foliaset'", ")", "instance", ".", "append", "(", "LemmaAnnotation", "(", "doc", ",", "cls", "=", "dcoilemma", ")", ")", "if", "dcoicorrection", "and", "dcoicorrectionoriginal", "and", "text", ":", "if", "not", "AnnotationType", ".", "CORRECTION", "in", "doc", ".", "annotationdefaults", ":", "doc", ".", "declare", "(", "AnnotationType", ".", "CORRECTION", ",", "set", "=", "'http://ilk.uvt.nl/folia/sets/dcoi-corrections.foliaset'", ")", "instance", ".", "correct", "(", "generate_id_in", "=", "instance", ",", "cls", "=", "dcoicorrection", ",", "original", "=", "dcoicorrectionoriginal", ",", "new", "=", "text", ")", "if", "doc", ".", "parsexmlcallback", ":", "result", "=", "doc", ".", "parsexmlcallback", "(", "instance", ")", "if", "not", "result", ":", "return", "None", "if", "isinstance", "(", "result", ",", "AbstractElement", ")", ":", "return", "result", "return", "instance" ]
Internal class method used for turning an XML element into an instance of the Class. Args: * ``node`` - XML Element * ``doc`` - Document Returns: An instance of the current Class.
[ "Internal", "class", "method", "used", "for", "turning", "an", "XML", "element", "into", "an", "instance", "of", "the", "Class", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2582-L2724
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.remove
def remove(self, child): """Removes the child element""" if not isinstance(child, AbstractElement): raise ValueError("Expected AbstractElement, got " + str(type(child))) if child.parent == self: child.parent = None self.data.remove(child) #delete from index if child.id and self.doc and child.id in self.doc.index: del self.doc.index[child.id]
python
def remove(self, child): """Removes the child element""" if not isinstance(child, AbstractElement): raise ValueError("Expected AbstractElement, got " + str(type(child))) if child.parent == self: child.parent = None self.data.remove(child) #delete from index if child.id and self.doc and child.id in self.doc.index: del self.doc.index[child.id]
[ "def", "remove", "(", "self", ",", "child", ")", ":", "if", "not", "isinstance", "(", "child", ",", "AbstractElement", ")", ":", "raise", "ValueError", "(", "\"Expected AbstractElement, got \"", "+", "str", "(", "type", "(", "child", ")", ")", ")", "if", "child", ".", "parent", "==", "self", ":", "child", ".", "parent", "=", "None", "self", ".", "data", ".", "remove", "(", "child", ")", "#delete from index", "if", "child", ".", "id", "and", "self", ".", "doc", "and", "child", ".", "id", "in", "self", ".", "doc", ".", "index", ":", "del", "self", ".", "doc", ".", "index", "[", "child", ".", "id", "]" ]
Removes the child element
[ "Removes", "the", "child", "element" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2729-L2738
proycon/pynlpl
pynlpl/formats/folia.py
AbstractElement.incorrection
def incorrection(self): """Is this element part of a correction? If it is, it returns the Correction element (evaluating to True), otherwise it returns None""" e = self.parent while e: if isinstance(e, Correction): return e if isinstance(e, AbstractStructureElement): break e = e.parent return None
python
def incorrection(self): """Is this element part of a correction? If it is, it returns the Correction element (evaluating to True), otherwise it returns None""" e = self.parent while e: if isinstance(e, Correction): return e if isinstance(e, AbstractStructureElement): break e = e.parent return None
[ "def", "incorrection", "(", "self", ")", ":", "e", "=", "self", ".", "parent", "while", "e", ":", "if", "isinstance", "(", "e", ",", "Correction", ")", ":", "return", "e", "if", "isinstance", "(", "e", ",", "AbstractStructureElement", ")", ":", "break", "e", "=", "e", ".", "parent", "return", "None" ]
Is this element part of a correction? If it is, it returns the Correction element (evaluating to True), otherwise it returns None
[ "Is", "this", "element", "part", "of", "a", "correction?", "If", "it", "is", "it", "returns", "the", "Correction", "element", "(", "evaluating", "to", "True", ")", "otherwise", "it", "returns", "None" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2740-L2750
proycon/pynlpl
pynlpl/formats/folia.py
AllowCorrections.correct
def correct(self, **kwargs): """Apply a correction (TODO: documentation to be written still)""" if 'insertindex_offset' in kwargs: del kwargs['insertindex_offset'] #dealt with in an earlier stage if 'confidence' in kwargs and kwargs['confidence'] is None: del kwargs['confidence'] if 'reuse' in kwargs: #reuse an existing correction instead of making a new one if isinstance(kwargs['reuse'], Correction): c = kwargs['reuse'] else: #assume it's an index try: c = self.doc.index[kwargs['reuse']] assert isinstance(c, Correction) except: raise ValueError("reuse= must point to an existing correction (id or instance)! Got " + str(kwargs['reuse'])) suggestionsonly = (not c.hasnew(True) and not c.hasoriginal(True) and c.hassuggestions(True)) if 'new' in kwargs and c.hascurrent(): #can't add new if there's current, so first set original to current, and then delete current if 'current' in kwargs: raise Exception("Can't set both new= and current= !") if 'original' not in kwargs: kwargs['original'] = c.current() c.remove(c.current()) else: if 'id' not in kwargs and 'generate_id_in' not in kwargs: kwargs['generate_id_in'] = self kwargs2 = copy(kwargs) for x in ['new','original','suggestion', 'suggestions','current', 'insertindex','nooriginal']: if x in kwargs2: del kwargs2[x] c = Correction(self.doc, **kwargs2) addnew = False if 'insertindex' in kwargs: insertindex = int(kwargs['insertindex']) del kwargs['insertindex'] else: insertindex = -1 #append if 'nooriginal' in kwargs and kwargs['nooriginal']: nooriginal = True del kwargs['nooriginal'] else: nooriginal = False if 'current' in kwargs: if 'original' in kwargs or 'new' in kwargs: raise Exception("When setting current=, original= and new= can not be set!") if not isinstance(kwargs['current'], list) and not isinstance(kwargs['current'], tuple): kwargs['current'] = [kwargs['current']] #support both lists (for multiple elements at once), as well as single element c.replace(Current(self.doc, *kwargs['current'])) for o in kwargs['current']: #delete current from current element if o in self and isinstance(o, AbstractElement): #pylint: disable=unsupported-membership-test if insertindex == -1: insertindex = self.data.index(o) self.remove(o) del kwargs['current'] if 'new' in kwargs: if not isinstance(kwargs['new'], list) and not isinstance(kwargs['new'], tuple): kwargs['new'] = [kwargs['new']] #support both lists (for multiple elements at once), as well as single element addnew = New(self.doc, *kwargs['new']) #pylint: disable=redefined-variable-type c.replace(addnew) for current in c.select(Current): #delete current if present c.remove(current) del kwargs['new'] if 'original' in kwargs and kwargs['original']: if not isinstance(kwargs['original'], list) and not isinstance(kwargs['original'], tuple): kwargs['original'] = [kwargs['original']] #support both lists (for multiple elements at once), as well as single element c.replace(Original(self.doc, *kwargs['original'])) for o in kwargs['original']: #delete original from current element if o in self and isinstance(o, AbstractElement): #pylint: disable=unsupported-membership-test if insertindex == -1: insertindex = self.data.index(o) self.remove(o) for o in kwargs['original']: #make sure IDs are still properly set after removal o.addtoindex() for current in c.select(Current): #delete current if present c.remove(current) del kwargs['original'] elif addnew and not nooriginal: #original not specified, find automagically: original = [] for new in addnew: kwargs2 = {} if isinstance(new, TextContent): kwargs2['cls'] = new.cls try: set = new.set except AttributeError: set = None #print("DEBUG: Finding replaceables within " + str(repr(self)) + " for ", str(repr(new)), " set " ,set , " args " ,repr(kwargs2),file=sys.stderr) replaceables = new.__class__.findreplaceables(self, set, **kwargs2) #print("DEBUG: " , len(replaceables) , " found",file=sys.stderr) original += replaceables if not original: #print("DEBUG: ", self.xmlstring(),file=sys.stderr) raise Exception("No original= specified and unable to automatically infer on " + str(repr(self)) + " for " + str(repr(new)) + " with set " + set) else: c.replace( Original(self.doc, *original)) for current in c.select(Current): #delete current if present c.remove(current) if addnew and not nooriginal: for original in c.original(): if original in self: #pylint: disable=unsupported-membership-test self.remove(original) if 'suggestion' in kwargs: kwargs['suggestions'] = [kwargs['suggestion']] del kwargs['suggestion'] if 'suggestions' in kwargs: for suggestion in kwargs['suggestions']: if isinstance(suggestion, Suggestion): c.append(suggestion) elif isinstance(suggestion, list) or isinstance(suggestion, tuple): c.append(Suggestion(self.doc, *suggestion)) else: c.append(Suggestion(self.doc, suggestion)) del kwargs['suggestions'] if 'reuse' in kwargs: if addnew and suggestionsonly: #What was previously only a suggestion, now becomes a real correction #If annotator, annotatortypes #are associated with the correction as a whole, move it to the suggestions #correction-wide annotator, annotatortypes might be overwritten for suggestion in c.suggestions(): if c.annotator and not suggestion.annotator: suggestion.annotator = c.annotator if c.annotatortype and not suggestion.annotatortype: suggestion.annotatortype = c.annotatortype if 'annotator' in kwargs: c.annotator = kwargs['annotator'] #pylint: disable=attribute-defined-outside-init if 'annotatortype' in kwargs: c.annotatortype = kwargs['annotatortype'] #pylint: disable=attribute-defined-outside-init if 'confidence' in kwargs: c.confidence = float(kwargs['confidence']) #pylint: disable=attribute-defined-outside-init c.addtoindex() del kwargs['reuse'] else: c.addtoindex() if insertindex == -1: self.append(c) else: self.insert(insertindex, c) return c
python
def correct(self, **kwargs): """Apply a correction (TODO: documentation to be written still)""" if 'insertindex_offset' in kwargs: del kwargs['insertindex_offset'] #dealt with in an earlier stage if 'confidence' in kwargs and kwargs['confidence'] is None: del kwargs['confidence'] if 'reuse' in kwargs: #reuse an existing correction instead of making a new one if isinstance(kwargs['reuse'], Correction): c = kwargs['reuse'] else: #assume it's an index try: c = self.doc.index[kwargs['reuse']] assert isinstance(c, Correction) except: raise ValueError("reuse= must point to an existing correction (id or instance)! Got " + str(kwargs['reuse'])) suggestionsonly = (not c.hasnew(True) and not c.hasoriginal(True) and c.hassuggestions(True)) if 'new' in kwargs and c.hascurrent(): #can't add new if there's current, so first set original to current, and then delete current if 'current' in kwargs: raise Exception("Can't set both new= and current= !") if 'original' not in kwargs: kwargs['original'] = c.current() c.remove(c.current()) else: if 'id' not in kwargs and 'generate_id_in' not in kwargs: kwargs['generate_id_in'] = self kwargs2 = copy(kwargs) for x in ['new','original','suggestion', 'suggestions','current', 'insertindex','nooriginal']: if x in kwargs2: del kwargs2[x] c = Correction(self.doc, **kwargs2) addnew = False if 'insertindex' in kwargs: insertindex = int(kwargs['insertindex']) del kwargs['insertindex'] else: insertindex = -1 #append if 'nooriginal' in kwargs and kwargs['nooriginal']: nooriginal = True del kwargs['nooriginal'] else: nooriginal = False if 'current' in kwargs: if 'original' in kwargs or 'new' in kwargs: raise Exception("When setting current=, original= and new= can not be set!") if not isinstance(kwargs['current'], list) and not isinstance(kwargs['current'], tuple): kwargs['current'] = [kwargs['current']] #support both lists (for multiple elements at once), as well as single element c.replace(Current(self.doc, *kwargs['current'])) for o in kwargs['current']: #delete current from current element if o in self and isinstance(o, AbstractElement): #pylint: disable=unsupported-membership-test if insertindex == -1: insertindex = self.data.index(o) self.remove(o) del kwargs['current'] if 'new' in kwargs: if not isinstance(kwargs['new'], list) and not isinstance(kwargs['new'], tuple): kwargs['new'] = [kwargs['new']] #support both lists (for multiple elements at once), as well as single element addnew = New(self.doc, *kwargs['new']) #pylint: disable=redefined-variable-type c.replace(addnew) for current in c.select(Current): #delete current if present c.remove(current) del kwargs['new'] if 'original' in kwargs and kwargs['original']: if not isinstance(kwargs['original'], list) and not isinstance(kwargs['original'], tuple): kwargs['original'] = [kwargs['original']] #support both lists (for multiple elements at once), as well as single element c.replace(Original(self.doc, *kwargs['original'])) for o in kwargs['original']: #delete original from current element if o in self and isinstance(o, AbstractElement): #pylint: disable=unsupported-membership-test if insertindex == -1: insertindex = self.data.index(o) self.remove(o) for o in kwargs['original']: #make sure IDs are still properly set after removal o.addtoindex() for current in c.select(Current): #delete current if present c.remove(current) del kwargs['original'] elif addnew and not nooriginal: #original not specified, find automagically: original = [] for new in addnew: kwargs2 = {} if isinstance(new, TextContent): kwargs2['cls'] = new.cls try: set = new.set except AttributeError: set = None #print("DEBUG: Finding replaceables within " + str(repr(self)) + " for ", str(repr(new)), " set " ,set , " args " ,repr(kwargs2),file=sys.stderr) replaceables = new.__class__.findreplaceables(self, set, **kwargs2) #print("DEBUG: " , len(replaceables) , " found",file=sys.stderr) original += replaceables if not original: #print("DEBUG: ", self.xmlstring(),file=sys.stderr) raise Exception("No original= specified and unable to automatically infer on " + str(repr(self)) + " for " + str(repr(new)) + " with set " + set) else: c.replace( Original(self.doc, *original)) for current in c.select(Current): #delete current if present c.remove(current) if addnew and not nooriginal: for original in c.original(): if original in self: #pylint: disable=unsupported-membership-test self.remove(original) if 'suggestion' in kwargs: kwargs['suggestions'] = [kwargs['suggestion']] del kwargs['suggestion'] if 'suggestions' in kwargs: for suggestion in kwargs['suggestions']: if isinstance(suggestion, Suggestion): c.append(suggestion) elif isinstance(suggestion, list) or isinstance(suggestion, tuple): c.append(Suggestion(self.doc, *suggestion)) else: c.append(Suggestion(self.doc, suggestion)) del kwargs['suggestions'] if 'reuse' in kwargs: if addnew and suggestionsonly: #What was previously only a suggestion, now becomes a real correction #If annotator, annotatortypes #are associated with the correction as a whole, move it to the suggestions #correction-wide annotator, annotatortypes might be overwritten for suggestion in c.suggestions(): if c.annotator and not suggestion.annotator: suggestion.annotator = c.annotator if c.annotatortype and not suggestion.annotatortype: suggestion.annotatortype = c.annotatortype if 'annotator' in kwargs: c.annotator = kwargs['annotator'] #pylint: disable=attribute-defined-outside-init if 'annotatortype' in kwargs: c.annotatortype = kwargs['annotatortype'] #pylint: disable=attribute-defined-outside-init if 'confidence' in kwargs: c.confidence = float(kwargs['confidence']) #pylint: disable=attribute-defined-outside-init c.addtoindex() del kwargs['reuse'] else: c.addtoindex() if insertindex == -1: self.append(c) else: self.insert(insertindex, c) return c
[ "def", "correct", "(", "self", ",", "*", "*", "kwargs", ")", ":", "if", "'insertindex_offset'", "in", "kwargs", ":", "del", "kwargs", "[", "'insertindex_offset'", "]", "#dealt with in an earlier stage", "if", "'confidence'", "in", "kwargs", "and", "kwargs", "[", "'confidence'", "]", "is", "None", ":", "del", "kwargs", "[", "'confidence'", "]", "if", "'reuse'", "in", "kwargs", ":", "#reuse an existing correction instead of making a new one", "if", "isinstance", "(", "kwargs", "[", "'reuse'", "]", ",", "Correction", ")", ":", "c", "=", "kwargs", "[", "'reuse'", "]", "else", ":", "#assume it's an index", "try", ":", "c", "=", "self", ".", "doc", ".", "index", "[", "kwargs", "[", "'reuse'", "]", "]", "assert", "isinstance", "(", "c", ",", "Correction", ")", "except", ":", "raise", "ValueError", "(", "\"reuse= must point to an existing correction (id or instance)! Got \"", "+", "str", "(", "kwargs", "[", "'reuse'", "]", ")", ")", "suggestionsonly", "=", "(", "not", "c", ".", "hasnew", "(", "True", ")", "and", "not", "c", ".", "hasoriginal", "(", "True", ")", "and", "c", ".", "hassuggestions", "(", "True", ")", ")", "if", "'new'", "in", "kwargs", "and", "c", ".", "hascurrent", "(", ")", ":", "#can't add new if there's current, so first set original to current, and then delete current", "if", "'current'", "in", "kwargs", ":", "raise", "Exception", "(", "\"Can't set both new= and current= !\"", ")", "if", "'original'", "not", "in", "kwargs", ":", "kwargs", "[", "'original'", "]", "=", "c", ".", "current", "(", ")", "c", ".", "remove", "(", "c", ".", "current", "(", ")", ")", "else", ":", "if", "'id'", "not", "in", "kwargs", "and", "'generate_id_in'", "not", "in", "kwargs", ":", "kwargs", "[", "'generate_id_in'", "]", "=", "self", "kwargs2", "=", "copy", "(", "kwargs", ")", "for", "x", "in", "[", "'new'", ",", "'original'", ",", "'suggestion'", ",", "'suggestions'", ",", "'current'", ",", "'insertindex'", ",", "'nooriginal'", "]", ":", "if", "x", "in", "kwargs2", ":", "del", "kwargs2", "[", "x", "]", "c", "=", "Correction", "(", "self", ".", "doc", ",", "*", "*", "kwargs2", ")", "addnew", "=", "False", "if", "'insertindex'", "in", "kwargs", ":", "insertindex", "=", "int", "(", "kwargs", "[", "'insertindex'", "]", ")", "del", "kwargs", "[", "'insertindex'", "]", "else", ":", "insertindex", "=", "-", "1", "#append", "if", "'nooriginal'", "in", "kwargs", "and", "kwargs", "[", "'nooriginal'", "]", ":", "nooriginal", "=", "True", "del", "kwargs", "[", "'nooriginal'", "]", "else", ":", "nooriginal", "=", "False", "if", "'current'", "in", "kwargs", ":", "if", "'original'", "in", "kwargs", "or", "'new'", "in", "kwargs", ":", "raise", "Exception", "(", "\"When setting current=, original= and new= can not be set!\"", ")", "if", "not", "isinstance", "(", "kwargs", "[", "'current'", "]", ",", "list", ")", "and", "not", "isinstance", "(", "kwargs", "[", "'current'", "]", ",", "tuple", ")", ":", "kwargs", "[", "'current'", "]", "=", "[", "kwargs", "[", "'current'", "]", "]", "#support both lists (for multiple elements at once), as well as single element", "c", ".", "replace", "(", "Current", "(", "self", ".", "doc", ",", "*", "kwargs", "[", "'current'", "]", ")", ")", "for", "o", "in", "kwargs", "[", "'current'", "]", ":", "#delete current from current element", "if", "o", "in", "self", "and", "isinstance", "(", "o", ",", "AbstractElement", ")", ":", "#pylint: disable=unsupported-membership-test", "if", "insertindex", "==", "-", "1", ":", "insertindex", "=", "self", ".", "data", ".", "index", "(", "o", ")", "self", ".", "remove", "(", "o", ")", "del", "kwargs", "[", "'current'", "]", "if", "'new'", "in", "kwargs", ":", "if", "not", "isinstance", "(", "kwargs", "[", "'new'", "]", ",", "list", ")", "and", "not", "isinstance", "(", "kwargs", "[", "'new'", "]", ",", "tuple", ")", ":", "kwargs", "[", "'new'", "]", "=", "[", "kwargs", "[", "'new'", "]", "]", "#support both lists (for multiple elements at once), as well as single element", "addnew", "=", "New", "(", "self", ".", "doc", ",", "*", "kwargs", "[", "'new'", "]", ")", "#pylint: disable=redefined-variable-type", "c", ".", "replace", "(", "addnew", ")", "for", "current", "in", "c", ".", "select", "(", "Current", ")", ":", "#delete current if present", "c", ".", "remove", "(", "current", ")", "del", "kwargs", "[", "'new'", "]", "if", "'original'", "in", "kwargs", "and", "kwargs", "[", "'original'", "]", ":", "if", "not", "isinstance", "(", "kwargs", "[", "'original'", "]", ",", "list", ")", "and", "not", "isinstance", "(", "kwargs", "[", "'original'", "]", ",", "tuple", ")", ":", "kwargs", "[", "'original'", "]", "=", "[", "kwargs", "[", "'original'", "]", "]", "#support both lists (for multiple elements at once), as well as single element", "c", ".", "replace", "(", "Original", "(", "self", ".", "doc", ",", "*", "kwargs", "[", "'original'", "]", ")", ")", "for", "o", "in", "kwargs", "[", "'original'", "]", ":", "#delete original from current element", "if", "o", "in", "self", "and", "isinstance", "(", "o", ",", "AbstractElement", ")", ":", "#pylint: disable=unsupported-membership-test", "if", "insertindex", "==", "-", "1", ":", "insertindex", "=", "self", ".", "data", ".", "index", "(", "o", ")", "self", ".", "remove", "(", "o", ")", "for", "o", "in", "kwargs", "[", "'original'", "]", ":", "#make sure IDs are still properly set after removal", "o", ".", "addtoindex", "(", ")", "for", "current", "in", "c", ".", "select", "(", "Current", ")", ":", "#delete current if present", "c", ".", "remove", "(", "current", ")", "del", "kwargs", "[", "'original'", "]", "elif", "addnew", "and", "not", "nooriginal", ":", "#original not specified, find automagically:", "original", "=", "[", "]", "for", "new", "in", "addnew", ":", "kwargs2", "=", "{", "}", "if", "isinstance", "(", "new", ",", "TextContent", ")", ":", "kwargs2", "[", "'cls'", "]", "=", "new", ".", "cls", "try", ":", "set", "=", "new", ".", "set", "except", "AttributeError", ":", "set", "=", "None", "#print(\"DEBUG: Finding replaceables within \" + str(repr(self)) + \" for \", str(repr(new)), \" set \" ,set , \" args \" ,repr(kwargs2),file=sys.stderr)", "replaceables", "=", "new", ".", "__class__", ".", "findreplaceables", "(", "self", ",", "set", ",", "*", "*", "kwargs2", ")", "#print(\"DEBUG: \" , len(replaceables) , \" found\",file=sys.stderr)", "original", "+=", "replaceables", "if", "not", "original", ":", "#print(\"DEBUG: \", self.xmlstring(),file=sys.stderr)", "raise", "Exception", "(", "\"No original= specified and unable to automatically infer on \"", "+", "str", "(", "repr", "(", "self", ")", ")", "+", "\" for \"", "+", "str", "(", "repr", "(", "new", ")", ")", "+", "\" with set \"", "+", "set", ")", "else", ":", "c", ".", "replace", "(", "Original", "(", "self", ".", "doc", ",", "*", "original", ")", ")", "for", "current", "in", "c", ".", "select", "(", "Current", ")", ":", "#delete current if present", "c", ".", "remove", "(", "current", ")", "if", "addnew", "and", "not", "nooriginal", ":", "for", "original", "in", "c", ".", "original", "(", ")", ":", "if", "original", "in", "self", ":", "#pylint: disable=unsupported-membership-test", "self", ".", "remove", "(", "original", ")", "if", "'suggestion'", "in", "kwargs", ":", "kwargs", "[", "'suggestions'", "]", "=", "[", "kwargs", "[", "'suggestion'", "]", "]", "del", "kwargs", "[", "'suggestion'", "]", "if", "'suggestions'", "in", "kwargs", ":", "for", "suggestion", "in", "kwargs", "[", "'suggestions'", "]", ":", "if", "isinstance", "(", "suggestion", ",", "Suggestion", ")", ":", "c", ".", "append", "(", "suggestion", ")", "elif", "isinstance", "(", "suggestion", ",", "list", ")", "or", "isinstance", "(", "suggestion", ",", "tuple", ")", ":", "c", ".", "append", "(", "Suggestion", "(", "self", ".", "doc", ",", "*", "suggestion", ")", ")", "else", ":", "c", ".", "append", "(", "Suggestion", "(", "self", ".", "doc", ",", "suggestion", ")", ")", "del", "kwargs", "[", "'suggestions'", "]", "if", "'reuse'", "in", "kwargs", ":", "if", "addnew", "and", "suggestionsonly", ":", "#What was previously only a suggestion, now becomes a real correction", "#If annotator, annotatortypes", "#are associated with the correction as a whole, move it to the suggestions", "#correction-wide annotator, annotatortypes might be overwritten", "for", "suggestion", "in", "c", ".", "suggestions", "(", ")", ":", "if", "c", ".", "annotator", "and", "not", "suggestion", ".", "annotator", ":", "suggestion", ".", "annotator", "=", "c", ".", "annotator", "if", "c", ".", "annotatortype", "and", "not", "suggestion", ".", "annotatortype", ":", "suggestion", ".", "annotatortype", "=", "c", ".", "annotatortype", "if", "'annotator'", "in", "kwargs", ":", "c", ".", "annotator", "=", "kwargs", "[", "'annotator'", "]", "#pylint: disable=attribute-defined-outside-init", "if", "'annotatortype'", "in", "kwargs", ":", "c", ".", "annotatortype", "=", "kwargs", "[", "'annotatortype'", "]", "#pylint: disable=attribute-defined-outside-init", "if", "'confidence'", "in", "kwargs", ":", "c", ".", "confidence", "=", "float", "(", "kwargs", "[", "'confidence'", "]", ")", "#pylint: disable=attribute-defined-outside-init", "c", ".", "addtoindex", "(", ")", "del", "kwargs", "[", "'reuse'", "]", "else", ":", "c", ".", "addtoindex", "(", ")", "if", "insertindex", "==", "-", "1", ":", "self", ".", "append", "(", "c", ")", "else", ":", "self", ".", "insert", "(", "insertindex", ",", "c", ")", "return", "c" ]
Apply a correction (TODO: documentation to be written still)
[ "Apply", "a", "correction", "(", "TODO", ":", "documentation", "to", "be", "written", "still", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L2856-L3007
proycon/pynlpl
pynlpl/formats/folia.py
AllowTokenAnnotation.annotations
def annotations(self,Class,set=None): """Obtain child elements (annotations) of the specified class. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. Yields: Elements (instances derived from :class:`AbstractElement`) Example:: for sense in text.annotations(folia.Sense, 'http://some/path/cornetto'): .. See also: :meth:`AbstractElement.select` Raises: :meth:`AllowTokenAnnotation.annotations` :class:`NoSuchAnnotation` if no such annotation exists """ found = False for e in self.select(Class,set,True,default_ignore_annotations): found = True yield e if not found: raise NoSuchAnnotation()
python
def annotations(self,Class,set=None): """Obtain child elements (annotations) of the specified class. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. Yields: Elements (instances derived from :class:`AbstractElement`) Example:: for sense in text.annotations(folia.Sense, 'http://some/path/cornetto'): .. See also: :meth:`AbstractElement.select` Raises: :meth:`AllowTokenAnnotation.annotations` :class:`NoSuchAnnotation` if no such annotation exists """ found = False for e in self.select(Class,set,True,default_ignore_annotations): found = True yield e if not found: raise NoSuchAnnotation()
[ "def", "annotations", "(", "self", ",", "Class", ",", "set", "=", "None", ")", ":", "found", "=", "False", "for", "e", "in", "self", ".", "select", "(", "Class", ",", "set", ",", "True", ",", "default_ignore_annotations", ")", ":", "found", "=", "True", "yield", "e", "if", "not", "found", ":", "raise", "NoSuchAnnotation", "(", ")" ]
Obtain child elements (annotations) of the specified class. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. Yields: Elements (instances derived from :class:`AbstractElement`) Example:: for sense in text.annotations(folia.Sense, 'http://some/path/cornetto'): .. See also: :meth:`AbstractElement.select` Raises: :meth:`AllowTokenAnnotation.annotations` :class:`NoSuchAnnotation` if no such annotation exists
[ "Obtain", "child", "elements", "(", "annotations", ")", "of", "the", "specified", "class", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3015-L3044
proycon/pynlpl
pynlpl/formats/folia.py
AllowTokenAnnotation.hasannotation
def hasannotation(self,Class,set=None): """Returns an integer indicating whether such as annotation exists, and if so, how many. See :meth:`AllowTokenAnnotation.annotations`` for a description of the parameters.""" return sum( 1 for _ in self.select(Class,set,True,default_ignore_annotations))
python
def hasannotation(self,Class,set=None): """Returns an integer indicating whether such as annotation exists, and if so, how many. See :meth:`AllowTokenAnnotation.annotations`` for a description of the parameters.""" return sum( 1 for _ in self.select(Class,set,True,default_ignore_annotations))
[ "def", "hasannotation", "(", "self", ",", "Class", ",", "set", "=", "None", ")", ":", "return", "sum", "(", "1", "for", "_", "in", "self", ".", "select", "(", "Class", ",", "set", ",", "True", ",", "default_ignore_annotations", ")", ")" ]
Returns an integer indicating whether such as annotation exists, and if so, how many. See :meth:`AllowTokenAnnotation.annotations`` for a description of the parameters.
[ "Returns", "an", "integer", "indicating", "whether", "such", "as", "annotation", "exists", "and", "if", "so", "how", "many", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3046-L3050
proycon/pynlpl
pynlpl/formats/folia.py
AllowTokenAnnotation.annotation
def annotation(self, type, set=None): """Obtain a single annotation element. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. Returns: An element (instance derived from :class:`AbstractElement`) Example:: sense = word.annotation(folia.Sense, 'http://some/path/cornetto').cls See also: :meth:`AllowTokenAnnotation.annotations` :meth:`AbstractElement.select` Raises: :class:`NoSuchAnnotation` if no such annotation exists """ """Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found""" for e in self.select(type,set,True,default_ignore_annotations): return e raise NoSuchAnnotation()
python
def annotation(self, type, set=None): """Obtain a single annotation element. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. Returns: An element (instance derived from :class:`AbstractElement`) Example:: sense = word.annotation(folia.Sense, 'http://some/path/cornetto').cls See also: :meth:`AllowTokenAnnotation.annotations` :meth:`AbstractElement.select` Raises: :class:`NoSuchAnnotation` if no such annotation exists """ """Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found""" for e in self.select(type,set,True,default_ignore_annotations): return e raise NoSuchAnnotation()
[ "def", "annotation", "(", "self", ",", "type", ",", "set", "=", "None", ")", ":", "\"\"\"Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found\"\"\"", "for", "e", "in", "self", ".", "select", "(", "type", ",", "set", ",", "True", ",", "default_ignore_annotations", ")", ":", "return", "e", "raise", "NoSuchAnnotation", "(", ")" ]
Obtain a single annotation element. A further restriction can be made based on set. Arguments: Class (class): The class to select; any python class (not instance) subclassed off :class:`AbstractElement` Set (str): The set to match against, only elements pertaining to this set will be returned. If set to None (default), all elements regardless of set will be returned. Returns: An element (instance derived from :class:`AbstractElement`) Example:: sense = word.annotation(folia.Sense, 'http://some/path/cornetto').cls See also: :meth:`AllowTokenAnnotation.annotations` :meth:`AbstractElement.select` Raises: :class:`NoSuchAnnotation` if no such annotation exists
[ "Obtain", "a", "single", "annotation", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3052-L3078
proycon/pynlpl
pynlpl/formats/folia.py
AbstractStructureElement.append
def append(self, child, *args, **kwargs): """See ``AbstractElement.append()``""" e = super(AbstractStructureElement,self).append(child, *args, **kwargs) self._setmaxid(e) return e
python
def append(self, child, *args, **kwargs): """See ``AbstractElement.append()``""" e = super(AbstractStructureElement,self).append(child, *args, **kwargs) self._setmaxid(e) return e
[ "def", "append", "(", "self", ",", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "e", "=", "super", "(", "AbstractStructureElement", ",", "self", ")", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", "self", ".", "_setmaxid", "(", "e", ")", "return", "e" ]
See ``AbstractElement.append()``
[ "See", "AbstractElement", ".", "append", "()" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3202-L3206
proycon/pynlpl
pynlpl/formats/folia.py
AbstractStructureElement.words
def words(self, index = None): """Returns a generator of Word elements found (recursively) under this element. Arguments: * ``index``: If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the list of all """ if index is None: return self.select(Word,None,True,default_ignore_structure) else: if index < 0: index = self.count(Word,None,True,default_ignore_structure) + index for i, e in enumerate(self.select(Word,None,True,default_ignore_structure)): if i == index: return e raise IndexError
python
def words(self, index = None): """Returns a generator of Word elements found (recursively) under this element. Arguments: * ``index``: If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the list of all """ if index is None: return self.select(Word,None,True,default_ignore_structure) else: if index < 0: index = self.count(Word,None,True,default_ignore_structure) + index for i, e in enumerate(self.select(Word,None,True,default_ignore_structure)): if i == index: return e raise IndexError
[ "def", "words", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "return", "self", ".", "select", "(", "Word", ",", "None", ",", "True", ",", "default_ignore_structure", ")", "else", ":", "if", "index", "<", "0", ":", "index", "=", "self", ".", "count", "(", "Word", ",", "None", ",", "True", ",", "default_ignore_structure", ")", "+", "index", "for", "i", ",", "e", "in", "enumerate", "(", "self", ".", "select", "(", "Word", ",", "None", ",", "True", ",", "default_ignore_structure", ")", ")", ":", "if", "i", "==", "index", ":", "return", "e", "raise", "IndexError" ]
Returns a generator of Word elements found (recursively) under this element. Arguments: * ``index``: If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the list of all
[ "Returns", "a", "generator", "of", "Word", "elements", "found", "(", "recursively", ")", "under", "this", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3214-L3228
proycon/pynlpl
pynlpl/formats/folia.py
AbstractStructureElement.paragraphs
def paragraphs(self, index = None): """Returns a generator of Paragraph elements found (recursively) under this element. Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the generator of all """ if index is None: return self.select(Paragraph,None,True,default_ignore_structure) else: if index < 0: index = self.count(Paragraph,None,True,default_ignore_structure) + index for i,e in enumerate(self.select(Paragraph,None,True,default_ignore_structure)): if i == index: return e raise IndexError
python
def paragraphs(self, index = None): """Returns a generator of Paragraph elements found (recursively) under this element. Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the generator of all """ if index is None: return self.select(Paragraph,None,True,default_ignore_structure) else: if index < 0: index = self.count(Paragraph,None,True,default_ignore_structure) + index for i,e in enumerate(self.select(Paragraph,None,True,default_ignore_structure)): if i == index: return e raise IndexError
[ "def", "paragraphs", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "return", "self", ".", "select", "(", "Paragraph", ",", "None", ",", "True", ",", "default_ignore_structure", ")", "else", ":", "if", "index", "<", "0", ":", "index", "=", "self", ".", "count", "(", "Paragraph", ",", "None", ",", "True", ",", "default_ignore_structure", ")", "+", "index", "for", "i", ",", "e", "in", "enumerate", "(", "self", ".", "select", "(", "Paragraph", ",", "None", ",", "True", ",", "default_ignore_structure", ")", ")", ":", "if", "i", "==", "index", ":", "return", "e", "raise", "IndexError" ]
Returns a generator of Paragraph elements found (recursively) under this element. Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the generator of all
[ "Returns", "a", "generator", "of", "Paragraph", "elements", "found", "(", "recursively", ")", "under", "this", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3231-L3245
proycon/pynlpl
pynlpl/formats/folia.py
AbstractStructureElement.sentences
def sentences(self, index = None): """Returns a generator of Sentence elements found (recursively) under this element Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning a generator of all """ if index is None: return self.select(Sentence,None,True,default_ignore_structure) else: if index < 0: index = self.count(Sentence,None,True,default_ignore_structure) + index for i,e in enumerate(self.select(Sentence,None,True,default_ignore_structure)): if i == index: return e raise IndexError
python
def sentences(self, index = None): """Returns a generator of Sentence elements found (recursively) under this element Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning a generator of all """ if index is None: return self.select(Sentence,None,True,default_ignore_structure) else: if index < 0: index = self.count(Sentence,None,True,default_ignore_structure) + index for i,e in enumerate(self.select(Sentence,None,True,default_ignore_structure)): if i == index: return e raise IndexError
[ "def", "sentences", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "return", "self", ".", "select", "(", "Sentence", ",", "None", ",", "True", ",", "default_ignore_structure", ")", "else", ":", "if", "index", "<", "0", ":", "index", "=", "self", ".", "count", "(", "Sentence", ",", "None", ",", "True", ",", "default_ignore_structure", ")", "+", "index", "for", "i", ",", "e", "in", "enumerate", "(", "self", ".", "select", "(", "Sentence", ",", "None", ",", "True", ",", "default_ignore_structure", ")", ")", ":", "if", "i", "==", "index", ":", "return", "e", "raise", "IndexError" ]
Returns a generator of Sentence elements found (recursively) under this element Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning a generator of all
[ "Returns", "a", "generator", "of", "Sentence", "elements", "found", "(", "recursively", ")", "under", "this", "element" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3247-L3261
proycon/pynlpl
pynlpl/formats/folia.py
AbstractStructureElement.layers
def layers(self, annotationtype=None,set=None): """Returns a list of annotation layers found *directly* under this element, does not include alternative layers""" if inspect.isclass(annotationtype): annotationtype = annotationtype.ANNOTATIONTYPE return [ x for x in self.select(AbstractAnnotationLayer,set,False,True) if annotationtype is None or x.ANNOTATIONTYPE == annotationtype ]
python
def layers(self, annotationtype=None,set=None): """Returns a list of annotation layers found *directly* under this element, does not include alternative layers""" if inspect.isclass(annotationtype): annotationtype = annotationtype.ANNOTATIONTYPE return [ x for x in self.select(AbstractAnnotationLayer,set,False,True) if annotationtype is None or x.ANNOTATIONTYPE == annotationtype ]
[ "def", "layers", "(", "self", ",", "annotationtype", "=", "None", ",", "set", "=", "None", ")", ":", "if", "inspect", ".", "isclass", "(", "annotationtype", ")", ":", "annotationtype", "=", "annotationtype", ".", "ANNOTATIONTYPE", "return", "[", "x", "for", "x", "in", "self", ".", "select", "(", "AbstractAnnotationLayer", ",", "set", ",", "False", ",", "True", ")", "if", "annotationtype", "is", "None", "or", "x", ".", "ANNOTATIONTYPE", "==", "annotationtype", "]" ]
Returns a list of annotation layers found *directly* under this element, does not include alternative layers
[ "Returns", "a", "list", "of", "annotation", "layers", "found", "*", "directly", "*", "under", "this", "element", "does", "not", "include", "alternative", "layers" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3263-L3266
proycon/pynlpl
pynlpl/formats/folia.py
AbstractStructureElement.hasannotationlayer
def hasannotationlayer(self, annotationtype=None,set=None): """Does the specified annotation layer exist?""" l = self.layers(annotationtype, set) return (len(l) > 0)
python
def hasannotationlayer(self, annotationtype=None,set=None): """Does the specified annotation layer exist?""" l = self.layers(annotationtype, set) return (len(l) > 0)
[ "def", "hasannotationlayer", "(", "self", ",", "annotationtype", "=", "None", ",", "set", "=", "None", ")", ":", "l", "=", "self", ".", "layers", "(", "annotationtype", ",", "set", ")", "return", "(", "len", "(", "l", ")", ">", "0", ")" ]
Does the specified annotation layer exist?
[ "Does", "the", "specified", "annotation", "layer", "exist?" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3268-L3271
proycon/pynlpl
pynlpl/formats/folia.py
AbstractTextMarkup.xml
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" if not attribs: attribs = {} if self.idref: attribs['id'] = self.idref return super(AbstractTextMarkup,self).xml(attribs,elements, skipchildren)
python
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" if not attribs: attribs = {} if self.idref: attribs['id'] = self.idref return super(AbstractTextMarkup,self).xml(attribs,elements, skipchildren)
[ "def", "xml", "(", "self", ",", "attribs", "=", "None", ",", "elements", "=", "None", ",", "skipchildren", "=", "False", ")", ":", "if", "not", "attribs", ":", "attribs", "=", "{", "}", "if", "self", ".", "idref", ":", "attribs", "[", "'id'", "]", "=", "self", ".", "idref", "return", "super", "(", "AbstractTextMarkup", ",", "self", ")", ".", "xml", "(", "attribs", ",", "elements", ",", "skipchildren", ")" ]
See :meth:`AbstractElement.xml`
[ "See", ":", "meth", ":", "AbstractElement", ".", "xml" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3336-L3341
proycon/pynlpl
pynlpl/formats/folia.py
AbstractTextMarkup.json
def json(self,attribs =None, recurse=True, ignorelist=False): """See :meth:`AbstractElement.json`""" if not attribs: attribs = {} if self.idref: attribs['id'] = self.idref return super(AbstractTextMarkup,self).json(attribs,recurse, ignorelist)
python
def json(self,attribs =None, recurse=True, ignorelist=False): """See :meth:`AbstractElement.json`""" if not attribs: attribs = {} if self.idref: attribs['id'] = self.idref return super(AbstractTextMarkup,self).json(attribs,recurse, ignorelist)
[ "def", "json", "(", "self", ",", "attribs", "=", "None", ",", "recurse", "=", "True", ",", "ignorelist", "=", "False", ")", ":", "if", "not", "attribs", ":", "attribs", "=", "{", "}", "if", "self", ".", "idref", ":", "attribs", "[", "'id'", "]", "=", "self", ".", "idref", "return", "super", "(", "AbstractTextMarkup", ",", "self", ")", ".", "json", "(", "attribs", ",", "recurse", ",", "ignorelist", ")" ]
See :meth:`AbstractElement.json`
[ "See", ":", "meth", ":", "AbstractElement", ".", "json" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3343-L3348
proycon/pynlpl
pynlpl/formats/folia.py
TextContent.text
def text(self, normalize_spaces=False): """Obtain the text (unicode instance)""" return super(TextContent,self).text(normalize_spaces=normalize_spaces)
python
def text(self, normalize_spaces=False): """Obtain the text (unicode instance)""" return super(TextContent,self).text(normalize_spaces=normalize_spaces)
[ "def", "text", "(", "self", ",", "normalize_spaces", "=", "False", ")", ":", "return", "super", "(", "TextContent", ",", "self", ")", ".", "text", "(", "normalize_spaces", "=", "normalize_spaces", ")" ]
Obtain the text (unicode instance)
[ "Obtain", "the", "text", "(", "unicode", "instance", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3490-L3492
proycon/pynlpl
pynlpl/formats/folia.py
TextContent.getreference
def getreference(self, validate=True): """Returns and validates the Text Content's reference. Raises UnresolvableTextContent when invalid""" if self.offset is None: return None #nothing to test if self.ref: ref = self.doc[self.ref] else: ref = self.finddefaultreference() if not ref: raise UnresolvableTextContent("Default reference for textcontent not found!") elif not ref.hastext(self.cls): raise UnresolvableTextContent("Reference (ID " + str(ref.id) + ") has no such text (class=" + self.cls+")") elif validate and self.text() != ref.textcontent(self.cls).text()[self.offset:self.offset+len(self.data[0])]: raise UnresolvableTextContent("Reference (ID " + str(ref.id) + ", class=" + self.cls+") found but no text match at specified offset ("+str(self.offset)+")! Expected '" + self.text() + "', got '" + ref.textcontent(self.cls).text()[self.offset:self.offset+len(self.data[0])] +"'") else: #finally, we made it! return ref
python
def getreference(self, validate=True): """Returns and validates the Text Content's reference. Raises UnresolvableTextContent when invalid""" if self.offset is None: return None #nothing to test if self.ref: ref = self.doc[self.ref] else: ref = self.finddefaultreference() if not ref: raise UnresolvableTextContent("Default reference for textcontent not found!") elif not ref.hastext(self.cls): raise UnresolvableTextContent("Reference (ID " + str(ref.id) + ") has no such text (class=" + self.cls+")") elif validate and self.text() != ref.textcontent(self.cls).text()[self.offset:self.offset+len(self.data[0])]: raise UnresolvableTextContent("Reference (ID " + str(ref.id) + ", class=" + self.cls+") found but no text match at specified offset ("+str(self.offset)+")! Expected '" + self.text() + "', got '" + ref.textcontent(self.cls).text()[self.offset:self.offset+len(self.data[0])] +"'") else: #finally, we made it! return ref
[ "def", "getreference", "(", "self", ",", "validate", "=", "True", ")", ":", "if", "self", ".", "offset", "is", "None", ":", "return", "None", "#nothing to test", "if", "self", ".", "ref", ":", "ref", "=", "self", ".", "doc", "[", "self", ".", "ref", "]", "else", ":", "ref", "=", "self", ".", "finddefaultreference", "(", ")", "if", "not", "ref", ":", "raise", "UnresolvableTextContent", "(", "\"Default reference for textcontent not found!\"", ")", "elif", "not", "ref", ".", "hastext", "(", "self", ".", "cls", ")", ":", "raise", "UnresolvableTextContent", "(", "\"Reference (ID \"", "+", "str", "(", "ref", ".", "id", ")", "+", "\") has no such text (class=\"", "+", "self", ".", "cls", "+", "\")\"", ")", "elif", "validate", "and", "self", ".", "text", "(", ")", "!=", "ref", ".", "textcontent", "(", "self", ".", "cls", ")", ".", "text", "(", ")", "[", "self", ".", "offset", ":", "self", ".", "offset", "+", "len", "(", "self", ".", "data", "[", "0", "]", ")", "]", ":", "raise", "UnresolvableTextContent", "(", "\"Reference (ID \"", "+", "str", "(", "ref", ".", "id", ")", "+", "\", class=\"", "+", "self", ".", "cls", "+", "\") found but no text match at specified offset (\"", "+", "str", "(", "self", ".", "offset", ")", "+", "\")! Expected '\"", "+", "self", ".", "text", "(", ")", "+", "\"', got '\"", "+", "ref", ".", "textcontent", "(", "self", ".", "cls", ")", ".", "text", "(", ")", "[", "self", ".", "offset", ":", "self", ".", "offset", "+", "len", "(", "self", ".", "data", "[", "0", "]", ")", "]", "+", "\"'\"", ")", "else", ":", "#finally, we made it!", "return", "ref" ]
Returns and validates the Text Content's reference. Raises UnresolvableTextContent when invalid
[ "Returns", "and", "validates", "the", "Text", "Content", "s", "reference", ".", "Raises", "UnresolvableTextContent", "when", "invalid" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3502-L3519
proycon/pynlpl
pynlpl/formats/folia.py
TextContent.xml
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" attribs = {} if not self.offset is None: attribs['{' + NSFOLIA + '}offset'] = str(self.offset) if self.parent and self.ref: attribs['{' + NSFOLIA + '}ref'] = self.ref #if self.cls != 'current' and not (self.cls == 'original' and any( isinstance(x, Original) for x in self.ancestors() ) ): # attribs['{' + NSFOLIA + '}class'] = self.cls #else: # if '{' + NSFOLIA + '}class' in attribs: # del attribs['{' + NSFOLIA + '}class'] #return E.t(self.value, **attribs) e = super(TextContent,self).xml(attribs,elements,skipchildren) if '{' + NSFOLIA + '}class' in e.attrib and e.attrib['{' + NSFOLIA + '}class'] == "current": #delete 'class=current' del e.attrib['{' + NSFOLIA + '}class'] return e
python
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" attribs = {} if not self.offset is None: attribs['{' + NSFOLIA + '}offset'] = str(self.offset) if self.parent and self.ref: attribs['{' + NSFOLIA + '}ref'] = self.ref #if self.cls != 'current' and not (self.cls == 'original' and any( isinstance(x, Original) for x in self.ancestors() ) ): # attribs['{' + NSFOLIA + '}class'] = self.cls #else: # if '{' + NSFOLIA + '}class' in attribs: # del attribs['{' + NSFOLIA + '}class'] #return E.t(self.value, **attribs) e = super(TextContent,self).xml(attribs,elements,skipchildren) if '{' + NSFOLIA + '}class' in e.attrib and e.attrib['{' + NSFOLIA + '}class'] == "current": #delete 'class=current' del e.attrib['{' + NSFOLIA + '}class'] return e
[ "def", "xml", "(", "self", ",", "attribs", "=", "None", ",", "elements", "=", "None", ",", "skipchildren", "=", "False", ")", ":", "attribs", "=", "{", "}", "if", "not", "self", ".", "offset", "is", "None", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}offset'", "]", "=", "str", "(", "self", ".", "offset", ")", "if", "self", ".", "parent", "and", "self", ".", "ref", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}ref'", "]", "=", "self", ".", "ref", "#if self.cls != 'current' and not (self.cls == 'original' and any( isinstance(x, Original) for x in self.ancestors() ) ):", "# attribs['{' + NSFOLIA + '}class'] = self.cls", "#else:", "# if '{' + NSFOLIA + '}class' in attribs:", "# del attribs['{' + NSFOLIA + '}class']", "#return E.t(self.value, **attribs)", "e", "=", "super", "(", "TextContent", ",", "self", ")", ".", "xml", "(", "attribs", ",", "elements", ",", "skipchildren", ")", "if", "'{'", "+", "NSFOLIA", "+", "'}class'", "in", "e", ".", "attrib", "and", "e", ".", "attrib", "[", "'{'", "+", "NSFOLIA", "+", "'}class'", "]", "==", "\"current\"", ":", "#delete 'class=current'", "del", "e", ".", "attrib", "[", "'{'", "+", "NSFOLIA", "+", "'}class'", "]", "return", "e" ]
See :meth:`AbstractElement.xml`
[ "See", ":", "meth", ":", "AbstractElement", ".", "xml" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3596-L3616
proycon/pynlpl
pynlpl/formats/folia.py
PhonContent.getreference
def getreference(self, validate=True): """Return and validate the Phonetic Content's reference. Raises UnresolvableTextContent when invalid""" if self.offset is None: return None #nothing to test if self.ref: ref = self.doc[self.ref] else: ref = self.finddefaultreference() if not ref: raise UnresolvableTextContent("Default reference for phonetic content not found!") elif not ref.hasphon(self.cls): raise UnresolvableTextContent("Reference has no such phonetic content (class=" + self.cls+")") elif validate and self.phon() != ref.textcontent(self.cls).phon()[self.offset:self.offset+len(self.data[0])]: raise UnresolvableTextContent("Reference (class=" + self.cls+") found but no phonetic match at specified offset ("+str(self.offset)+")! Expected '" + self.text() + "', got '" + ref.textcontent(self.cls).text()[self.offset:self.offset+len(self.data[0])] +"'") else: #finally, we made it! return ref
python
def getreference(self, validate=True): """Return and validate the Phonetic Content's reference. Raises UnresolvableTextContent when invalid""" if self.offset is None: return None #nothing to test if self.ref: ref = self.doc[self.ref] else: ref = self.finddefaultreference() if not ref: raise UnresolvableTextContent("Default reference for phonetic content not found!") elif not ref.hasphon(self.cls): raise UnresolvableTextContent("Reference has no such phonetic content (class=" + self.cls+")") elif validate and self.phon() != ref.textcontent(self.cls).phon()[self.offset:self.offset+len(self.data[0])]: raise UnresolvableTextContent("Reference (class=" + self.cls+") found but no phonetic match at specified offset ("+str(self.offset)+")! Expected '" + self.text() + "', got '" + ref.textcontent(self.cls).text()[self.offset:self.offset+len(self.data[0])] +"'") else: #finally, we made it! return ref
[ "def", "getreference", "(", "self", ",", "validate", "=", "True", ")", ":", "if", "self", ".", "offset", "is", "None", ":", "return", "None", "#nothing to test", "if", "self", ".", "ref", ":", "ref", "=", "self", ".", "doc", "[", "self", ".", "ref", "]", "else", ":", "ref", "=", "self", ".", "finddefaultreference", "(", ")", "if", "not", "ref", ":", "raise", "UnresolvableTextContent", "(", "\"Default reference for phonetic content not found!\"", ")", "elif", "not", "ref", ".", "hasphon", "(", "self", ".", "cls", ")", ":", "raise", "UnresolvableTextContent", "(", "\"Reference has no such phonetic content (class=\"", "+", "self", ".", "cls", "+", "\")\"", ")", "elif", "validate", "and", "self", ".", "phon", "(", ")", "!=", "ref", ".", "textcontent", "(", "self", ".", "cls", ")", ".", "phon", "(", ")", "[", "self", ".", "offset", ":", "self", ".", "offset", "+", "len", "(", "self", ".", "data", "[", "0", "]", ")", "]", ":", "raise", "UnresolvableTextContent", "(", "\"Reference (class=\"", "+", "self", ".", "cls", "+", "\") found but no phonetic match at specified offset (\"", "+", "str", "(", "self", ".", "offset", ")", "+", "\")! Expected '\"", "+", "self", ".", "text", "(", ")", "+", "\"', got '\"", "+", "ref", ".", "textcontent", "(", "self", ".", "cls", ")", ".", "text", "(", ")", "[", "self", ".", "offset", ":", "self", ".", "offset", "+", "len", "(", "self", ".", "data", "[", "0", "]", ")", "]", "+", "\"'\"", ")", "else", ":", "#finally, we made it!", "return", "ref" ]
Return and validate the Phonetic Content's reference. Raises UnresolvableTextContent when invalid
[ "Return", "and", "validate", "the", "Phonetic", "Content", "s", "reference", ".", "Raises", "UnresolvableTextContent", "when", "invalid" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3715-L3732
proycon/pynlpl
pynlpl/formats/folia.py
PhonContent.finddefaultreference
def finddefaultreference(self): """Find the default reference for text offsets: The parent of the current textcontent's parent (counting only Structure Elements and Subtoken Annotation Elements) Note: This returns not a TextContent element, but its parent. Whether the textcontent actually exists is checked later/elsewhere """ depth = 0 e = self while True: if e.parent: e = e.parent #pylint: disable=redefined-variable-type else: #no parent, breaking return False if isinstance(e,AbstractStructureElement) or isinstance(e,AbstractSubtokenAnnotation): depth += 1 if depth == 2: return e return False
python
def finddefaultreference(self): """Find the default reference for text offsets: The parent of the current textcontent's parent (counting only Structure Elements and Subtoken Annotation Elements) Note: This returns not a TextContent element, but its parent. Whether the textcontent actually exists is checked later/elsewhere """ depth = 0 e = self while True: if e.parent: e = e.parent #pylint: disable=redefined-variable-type else: #no parent, breaking return False if isinstance(e,AbstractStructureElement) or isinstance(e,AbstractSubtokenAnnotation): depth += 1 if depth == 2: return e return False
[ "def", "finddefaultreference", "(", "self", ")", ":", "depth", "=", "0", "e", "=", "self", "while", "True", ":", "if", "e", ".", "parent", ":", "e", "=", "e", ".", "parent", "#pylint: disable=redefined-variable-type", "else", ":", "#no parent, breaking", "return", "False", "if", "isinstance", "(", "e", ",", "AbstractStructureElement", ")", "or", "isinstance", "(", "e", ",", "AbstractSubtokenAnnotation", ")", ":", "depth", "+=", "1", "if", "depth", "==", "2", ":", "return", "e", "return", "False" ]
Find the default reference for text offsets: The parent of the current textcontent's parent (counting only Structure Elements and Subtoken Annotation Elements) Note: This returns not a TextContent element, but its parent. Whether the textcontent actually exists is checked later/elsewhere
[ "Find", "the", "default", "reference", "for", "text", "offsets", ":", "The", "parent", "of", "the", "current", "textcontent", "s", "parent", "(", "counting", "only", "Structure", "Elements", "and", "Subtoken", "Annotation", "Elements", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3765-L3787
proycon/pynlpl
pynlpl/formats/folia.py
PhonContent.findreplaceables
def findreplaceables(Class, parent, set, **kwargs):#pylint: disable=bad-classmethod-argument """(Method for internal usage, see AbstractElement)""" #some extra behaviour for text content elements, replace also based on the 'corrected' attribute: if 'cls' not in kwargs: kwargs['cls'] = 'current' replace = super(PhonContent, Class).findreplaceables(parent, set, **kwargs) replace = [ x for x in replace if x.cls == kwargs['cls']] del kwargs['cls'] #always delete what we processed return replace
python
def findreplaceables(Class, parent, set, **kwargs):#pylint: disable=bad-classmethod-argument """(Method for internal usage, see AbstractElement)""" #some extra behaviour for text content elements, replace also based on the 'corrected' attribute: if 'cls' not in kwargs: kwargs['cls'] = 'current' replace = super(PhonContent, Class).findreplaceables(parent, set, **kwargs) replace = [ x for x in replace if x.cls == kwargs['cls']] del kwargs['cls'] #always delete what we processed return replace
[ "def", "findreplaceables", "(", "Class", ",", "parent", ",", "set", ",", "*", "*", "kwargs", ")", ":", "#pylint: disable=bad-classmethod-argument", "#some extra behaviour for text content elements, replace also based on the 'corrected' attribute:", "if", "'cls'", "not", "in", "kwargs", ":", "kwargs", "[", "'cls'", "]", "=", "'current'", "replace", "=", "super", "(", "PhonContent", ",", "Class", ")", ".", "findreplaceables", "(", "parent", ",", "set", ",", "*", "*", "kwargs", ")", "replace", "=", "[", "x", "for", "x", "in", "replace", "if", "x", ".", "cls", "==", "kwargs", "[", "'cls'", "]", "]", "del", "kwargs", "[", "'cls'", "]", "#always delete what we processed", "return", "replace" ]
(Method for internal usage, see AbstractElement)
[ "(", "Method", "for", "internal", "usage", "see", "AbstractElement", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3796-L3804
proycon/pynlpl
pynlpl/formats/folia.py
PhonContent.parsexml
def parsexml(Class, node, doc, **kwargs):#pylint: disable=bad-classmethod-argument """(Method for internal usage, see AbstractElement)""" if not kwargs: kwargs = {} if 'offset' in node.attrib: kwargs['offset'] = int(node.attrib['offset']) if 'ref' in node.attrib: kwargs['ref'] = node.attrib['ref'] return super(PhonContent,Class).parsexml(node,doc, **kwargs)
python
def parsexml(Class, node, doc, **kwargs):#pylint: disable=bad-classmethod-argument """(Method for internal usage, see AbstractElement)""" if not kwargs: kwargs = {} if 'offset' in node.attrib: kwargs['offset'] = int(node.attrib['offset']) if 'ref' in node.attrib: kwargs['ref'] = node.attrib['ref'] return super(PhonContent,Class).parsexml(node,doc, **kwargs)
[ "def", "parsexml", "(", "Class", ",", "node", ",", "doc", ",", "*", "*", "kwargs", ")", ":", "#pylint: disable=bad-classmethod-argument", "if", "not", "kwargs", ":", "kwargs", "=", "{", "}", "if", "'offset'", "in", "node", ".", "attrib", ":", "kwargs", "[", "'offset'", "]", "=", "int", "(", "node", ".", "attrib", "[", "'offset'", "]", ")", "if", "'ref'", "in", "node", ".", "attrib", ":", "kwargs", "[", "'ref'", "]", "=", "node", ".", "attrib", "[", "'ref'", "]", "return", "super", "(", "PhonContent", ",", "Class", ")", ".", "parsexml", "(", "node", ",", "doc", ",", "*", "*", "kwargs", ")" ]
(Method for internal usage, see AbstractElement)
[ "(", "Method", "for", "internal", "usage", "see", "AbstractElement", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L3808-L3815
proycon/pynlpl
pynlpl/formats/folia.py
Word.morphemes
def morphemes(self,set=None): """Generator yielding all morphemes (in a particular set if specified). For retrieving one specific morpheme by index, use morpheme() instead""" for layer in self.select(MorphologyLayer): for m in layer.select(Morpheme, set): yield m
python
def morphemes(self,set=None): """Generator yielding all morphemes (in a particular set if specified). For retrieving one specific morpheme by index, use morpheme() instead""" for layer in self.select(MorphologyLayer): for m in layer.select(Morpheme, set): yield m
[ "def", "morphemes", "(", "self", ",", "set", "=", "None", ")", ":", "for", "layer", "in", "self", ".", "select", "(", "MorphologyLayer", ")", ":", "for", "m", "in", "layer", ".", "select", "(", "Morpheme", ",", "set", ")", ":", "yield", "m" ]
Generator yielding all morphemes (in a particular set if specified). For retrieving one specific morpheme by index, use morpheme() instead
[ "Generator", "yielding", "all", "morphemes", "(", "in", "a", "particular", "set", "if", "specified", ")", ".", "For", "retrieving", "one", "specific", "morpheme", "by", "index", "use", "morpheme", "()", "instead" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4081-L4085
proycon/pynlpl
pynlpl/formats/folia.py
Word.phonemes
def phonemes(self,set=None): """Generator yielding all phonemes (in a particular set if specified). For retrieving one specific morpheme by index, use morpheme() instead""" for layer in self.select(PhonologyLayer): for p in layer.select(Phoneme, set): yield p
python
def phonemes(self,set=None): """Generator yielding all phonemes (in a particular set if specified). For retrieving one specific morpheme by index, use morpheme() instead""" for layer in self.select(PhonologyLayer): for p in layer.select(Phoneme, set): yield p
[ "def", "phonemes", "(", "self", ",", "set", "=", "None", ")", ":", "for", "layer", "in", "self", ".", "select", "(", "PhonologyLayer", ")", ":", "for", "p", "in", "layer", ".", "select", "(", "Phoneme", ",", "set", ")", ":", "yield", "p" ]
Generator yielding all phonemes (in a particular set if specified). For retrieving one specific morpheme by index, use morpheme() instead
[ "Generator", "yielding", "all", "phonemes", "(", "in", "a", "particular", "set", "if", "specified", ")", ".", "For", "retrieving", "one", "specific", "morpheme", "by", "index", "use", "morpheme", "()", "instead" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4087-L4091
proycon/pynlpl
pynlpl/formats/folia.py
Word.morpheme
def morpheme(self,index, set=None): """Returns a specific morpheme, the n'th morpheme (given the particular set if specified).""" for layer in self.select(MorphologyLayer): for i, m in enumerate(layer.select(Morpheme, set)): if index == i: return m raise NoSuchAnnotation
python
def morpheme(self,index, set=None): """Returns a specific morpheme, the n'th morpheme (given the particular set if specified).""" for layer in self.select(MorphologyLayer): for i, m in enumerate(layer.select(Morpheme, set)): if index == i: return m raise NoSuchAnnotation
[ "def", "morpheme", "(", "self", ",", "index", ",", "set", "=", "None", ")", ":", "for", "layer", "in", "self", ".", "select", "(", "MorphologyLayer", ")", ":", "for", "i", ",", "m", "in", "enumerate", "(", "layer", ".", "select", "(", "Morpheme", ",", "set", ")", ")", ":", "if", "index", "==", "i", ":", "return", "m", "raise", "NoSuchAnnotation" ]
Returns a specific morpheme, the n'th morpheme (given the particular set if specified).
[ "Returns", "a", "specific", "morpheme", "the", "n", "th", "morpheme", "(", "given", "the", "particular", "set", "if", "specified", ")", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4093-L4099
proycon/pynlpl
pynlpl/formats/folia.py
Word.phoneme
def phoneme(self,index, set=None): """Returns a specific phoneme, the n'th morpheme (given the particular set if specified).""" for layer in self.select(PhonologyLayer): for i, p in enumerate(layer.select(Phoneme, set)): if index == i: return p raise NoSuchAnnotation
python
def phoneme(self,index, set=None): """Returns a specific phoneme, the n'th morpheme (given the particular set if specified).""" for layer in self.select(PhonologyLayer): for i, p in enumerate(layer.select(Phoneme, set)): if index == i: return p raise NoSuchAnnotation
[ "def", "phoneme", "(", "self", ",", "index", ",", "set", "=", "None", ")", ":", "for", "layer", "in", "self", ".", "select", "(", "PhonologyLayer", ")", ":", "for", "i", ",", "p", "in", "enumerate", "(", "layer", ".", "select", "(", "Phoneme", ",", "set", ")", ")", ":", "if", "index", "==", "i", ":", "return", "p", "raise", "NoSuchAnnotation" ]
Returns a specific phoneme, the n'th morpheme (given the particular set if specified).
[ "Returns", "a", "specific", "phoneme", "the", "n", "th", "morpheme", "(", "given", "the", "particular", "set", "if", "specified", ")", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4102-L4108
proycon/pynlpl
pynlpl/formats/folia.py
Word.findspans
def findspans(self, type,set=None): """Yields span annotation elements of the specified type that include this word. Arguments: type: The annotation type, can be passed as using any of the :class:`AnnotationType` member, or by passing the relevant :class:`AbstractSpanAnnotation` or :class:`AbstractAnnotationLayer` class. set (str or None): Constrain by set Example:: for chunk in word.findspans(folia.Chunk): print(" Chunk class=", chunk.cls, " words=") for word2 in chunk.wrefs(): #print all words in the chunk (of which the word is a part) print(word2, end="") print() Yields: Matching span annotation instances (derived from :class:`AbstractSpanAnnotation`) """ if issubclass(type, AbstractAnnotationLayer): layerclass = type else: layerclass = ANNOTATIONTYPE2LAYERCLASS[type.ANNOTATIONTYPE] e = self while True: if not e.parent: break e = e.parent for layer in e.select(layerclass,set,False): if type is layerclass: for e2 in layer.select(AbstractSpanAnnotation,set,True, (True, Word, Morpheme)): if not isinstance(e2, AbstractSpanRole) and self in e2.wrefs(): yield e2 else: for e2 in layer.select(type,set,True, (True, Word, Morpheme)): if not isinstance(e2, AbstractSpanRole) and self in e2.wrefs(): yield e2
python
def findspans(self, type,set=None): """Yields span annotation elements of the specified type that include this word. Arguments: type: The annotation type, can be passed as using any of the :class:`AnnotationType` member, or by passing the relevant :class:`AbstractSpanAnnotation` or :class:`AbstractAnnotationLayer` class. set (str or None): Constrain by set Example:: for chunk in word.findspans(folia.Chunk): print(" Chunk class=", chunk.cls, " words=") for word2 in chunk.wrefs(): #print all words in the chunk (of which the word is a part) print(word2, end="") print() Yields: Matching span annotation instances (derived from :class:`AbstractSpanAnnotation`) """ if issubclass(type, AbstractAnnotationLayer): layerclass = type else: layerclass = ANNOTATIONTYPE2LAYERCLASS[type.ANNOTATIONTYPE] e = self while True: if not e.parent: break e = e.parent for layer in e.select(layerclass,set,False): if type is layerclass: for e2 in layer.select(AbstractSpanAnnotation,set,True, (True, Word, Morpheme)): if not isinstance(e2, AbstractSpanRole) and self in e2.wrefs(): yield e2 else: for e2 in layer.select(type,set,True, (True, Word, Morpheme)): if not isinstance(e2, AbstractSpanRole) and self in e2.wrefs(): yield e2
[ "def", "findspans", "(", "self", ",", "type", ",", "set", "=", "None", ")", ":", "if", "issubclass", "(", "type", ",", "AbstractAnnotationLayer", ")", ":", "layerclass", "=", "type", "else", ":", "layerclass", "=", "ANNOTATIONTYPE2LAYERCLASS", "[", "type", ".", "ANNOTATIONTYPE", "]", "e", "=", "self", "while", "True", ":", "if", "not", "e", ".", "parent", ":", "break", "e", "=", "e", ".", "parent", "for", "layer", "in", "e", ".", "select", "(", "layerclass", ",", "set", ",", "False", ")", ":", "if", "type", "is", "layerclass", ":", "for", "e2", "in", "layer", ".", "select", "(", "AbstractSpanAnnotation", ",", "set", ",", "True", ",", "(", "True", ",", "Word", ",", "Morpheme", ")", ")", ":", "if", "not", "isinstance", "(", "e2", ",", "AbstractSpanRole", ")", "and", "self", "in", "e2", ".", "wrefs", "(", ")", ":", "yield", "e2", "else", ":", "for", "e2", "in", "layer", ".", "select", "(", "type", ",", "set", ",", "True", ",", "(", "True", ",", "Word", ",", "Morpheme", ")", ")", ":", "if", "not", "isinstance", "(", "e2", ",", "AbstractSpanRole", ")", "and", "self", "in", "e2", ".", "wrefs", "(", ")", ":", "yield", "e2" ]
Yields span annotation elements of the specified type that include this word. Arguments: type: The annotation type, can be passed as using any of the :class:`AnnotationType` member, or by passing the relevant :class:`AbstractSpanAnnotation` or :class:`AbstractAnnotationLayer` class. set (str or None): Constrain by set Example:: for chunk in word.findspans(folia.Chunk): print(" Chunk class=", chunk.cls, " words=") for word2 in chunk.wrefs(): #print all words in the chunk (of which the word is a part) print(word2, end="") print() Yields: Matching span annotation instances (derived from :class:`AbstractSpanAnnotation`)
[ "Yields", "span", "annotation", "elements", "of", "the", "specified", "type", "that", "include", "this", "word", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4178-L4213
proycon/pynlpl
pynlpl/formats/folia.py
Feature.deepvalidation
def deepvalidation(self): """Perform deep validation of this element. Raises: :class:`DeepValidationError` """ if self.doc and self.doc.deepvalidation and self.parent.set and self.parent.set[0] != '_': try: self.doc.setdefinitions[self.parent.set].testsubclass(self.parent.cls, self.subset, self.cls) except KeyError as e: if self.parent.cls and not self.doc.allowadhocsets: raise DeepValidationError("Set definition " + self.parent.set + " for " + self.parent.XMLTAG + " not loaded (feature validation failed)!") except DeepValidationError as e: errormsg = str(e) + " (in set " + self.parent.set+" for " + self.parent.XMLTAG if self.parent.id: errormsg += " with ID " + self.parent.id errormsg += ")" raise DeepValidationError(errormsg)
python
def deepvalidation(self): """Perform deep validation of this element. Raises: :class:`DeepValidationError` """ if self.doc and self.doc.deepvalidation and self.parent.set and self.parent.set[0] != '_': try: self.doc.setdefinitions[self.parent.set].testsubclass(self.parent.cls, self.subset, self.cls) except KeyError as e: if self.parent.cls and not self.doc.allowadhocsets: raise DeepValidationError("Set definition " + self.parent.set + " for " + self.parent.XMLTAG + " not loaded (feature validation failed)!") except DeepValidationError as e: errormsg = str(e) + " (in set " + self.parent.set+" for " + self.parent.XMLTAG if self.parent.id: errormsg += " with ID " + self.parent.id errormsg += ")" raise DeepValidationError(errormsg)
[ "def", "deepvalidation", "(", "self", ")", ":", "if", "self", ".", "doc", "and", "self", ".", "doc", ".", "deepvalidation", "and", "self", ".", "parent", ".", "set", "and", "self", ".", "parent", ".", "set", "[", "0", "]", "!=", "'_'", ":", "try", ":", "self", ".", "doc", ".", "setdefinitions", "[", "self", ".", "parent", ".", "set", "]", ".", "testsubclass", "(", "self", ".", "parent", ".", "cls", ",", "self", ".", "subset", ",", "self", ".", "cls", ")", "except", "KeyError", "as", "e", ":", "if", "self", ".", "parent", ".", "cls", "and", "not", "self", ".", "doc", ".", "allowadhocsets", ":", "raise", "DeepValidationError", "(", "\"Set definition \"", "+", "self", ".", "parent", ".", "set", "+", "\" for \"", "+", "self", ".", "parent", ".", "XMLTAG", "+", "\" not loaded (feature validation failed)!\"", ")", "except", "DeepValidationError", "as", "e", ":", "errormsg", "=", "str", "(", "e", ")", "+", "\" (in set \"", "+", "self", ".", "parent", ".", "set", "+", "\" for \"", "+", "self", ".", "parent", ".", "XMLTAG", "if", "self", ".", "parent", ".", "id", ":", "errormsg", "+=", "\" with ID \"", "+", "self", ".", "parent", ".", "id", "errormsg", "+=", "\")\"", "raise", "DeepValidationError", "(", "errormsg", ")" ]
Perform deep validation of this element. Raises: :class:`DeepValidationError`
[ "Perform", "deep", "validation", "of", "this", "element", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4283-L4300
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.xml
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" if not attribs: attribs = {} E = ElementMaker(namespace="http://ilk.uvt.nl/folia",nsmap={None: "http://ilk.uvt.nl/folia", 'xml' : "http://www.w3.org/XML/1998/namespace"}) e = super(AbstractSpanAnnotation,self).xml(attribs, elements, True) for child in self: if isinstance(child, (Word, Morpheme, Phoneme)): #Include REFERENCES to word items instead of word items themselves attribs['{' + NSFOLIA + '}id'] = child.id if child.PRINTABLE and child.hastext(self.textclass): attribs['{' + NSFOLIA + '}t'] = child.text(self.textclass) e.append( E.wref(**attribs) ) elif not (isinstance(child, Feature) and child.SUBSET): #Don't add pre-defined features, they are already added as attributes e.append( child.xml() ) return e
python
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" if not attribs: attribs = {} E = ElementMaker(namespace="http://ilk.uvt.nl/folia",nsmap={None: "http://ilk.uvt.nl/folia", 'xml' : "http://www.w3.org/XML/1998/namespace"}) e = super(AbstractSpanAnnotation,self).xml(attribs, elements, True) for child in self: if isinstance(child, (Word, Morpheme, Phoneme)): #Include REFERENCES to word items instead of word items themselves attribs['{' + NSFOLIA + '}id'] = child.id if child.PRINTABLE and child.hastext(self.textclass): attribs['{' + NSFOLIA + '}t'] = child.text(self.textclass) e.append( E.wref(**attribs) ) elif not (isinstance(child, Feature) and child.SUBSET): #Don't add pre-defined features, they are already added as attributes e.append( child.xml() ) return e
[ "def", "xml", "(", "self", ",", "attribs", "=", "None", ",", "elements", "=", "None", ",", "skipchildren", "=", "False", ")", ":", "if", "not", "attribs", ":", "attribs", "=", "{", "}", "E", "=", "ElementMaker", "(", "namespace", "=", "\"http://ilk.uvt.nl/folia\"", ",", "nsmap", "=", "{", "None", ":", "\"http://ilk.uvt.nl/folia\"", ",", "'xml'", ":", "\"http://www.w3.org/XML/1998/namespace\"", "}", ")", "e", "=", "super", "(", "AbstractSpanAnnotation", ",", "self", ")", ".", "xml", "(", "attribs", ",", "elements", ",", "True", ")", "for", "child", "in", "self", ":", "if", "isinstance", "(", "child", ",", "(", "Word", ",", "Morpheme", ",", "Phoneme", ")", ")", ":", "#Include REFERENCES to word items instead of word items themselves", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}id'", "]", "=", "child", ".", "id", "if", "child", ".", "PRINTABLE", "and", "child", ".", "hastext", "(", "self", ".", "textclass", ")", ":", "attribs", "[", "'{'", "+", "NSFOLIA", "+", "'}t'", "]", "=", "child", ".", "text", "(", "self", ".", "textclass", ")", "e", ".", "append", "(", "E", ".", "wref", "(", "*", "*", "attribs", ")", ")", "elif", "not", "(", "isinstance", "(", "child", ",", "Feature", ")", "and", "child", ".", "SUBSET", ")", ":", "#Don't add pre-defined features, they are already added as attributes", "e", ".", "append", "(", "child", ".", "xml", "(", ")", ")", "return", "e" ]
See :meth:`AbstractElement.xml`
[ "See", ":", "meth", ":", "AbstractElement", ".", "xml" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4320-L4334
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.append
def append(self, child, *args, **kwargs): """See :meth:`AbstractElement.append`""" #Accept Word instances instead of WordReference, references will be automagically used upon serialisation if isinstance(child, (Word, Morpheme, Phoneme)) and WordReference in self.ACCEPTED_DATA: #We don't really append but do an insertion so all references are in proper order insertionpoint = len(self.data) for i, sibling in enumerate(self.data): if isinstance(sibling, (Word, Morpheme, Phoneme)): try: if not sibling.precedes(child): insertionpoint = i except: #happens if we can't determine common ancestors pass self.data.insert(insertionpoint, child) return child elif isinstance(child, AbstractSpanAnnotation): #(covers span roles just as well) insertionpoint = len(self.data) try: firstword = child.wrefs(0) except IndexError: #we have no basis to determine an insertionpoint for this child, just append it then return super(AbstractSpanAnnotation,self).append(child, *args, **kwargs) insertionpoint = len(self.data) for i, sibling in enumerate(self.data): if isinstance(sibling, (Word, Morpheme, Phoneme)): try: if not sibling.precedes(firstword): insertionpoint = i except: #happens if we can't determine common ancestors pass return super(AbstractSpanAnnotation,self).insert(insertionpoint, child, *args, **kwargs) else: return super(AbstractSpanAnnotation,self).append(child, *args, **kwargs)
python
def append(self, child, *args, **kwargs): """See :meth:`AbstractElement.append`""" #Accept Word instances instead of WordReference, references will be automagically used upon serialisation if isinstance(child, (Word, Morpheme, Phoneme)) and WordReference in self.ACCEPTED_DATA: #We don't really append but do an insertion so all references are in proper order insertionpoint = len(self.data) for i, sibling in enumerate(self.data): if isinstance(sibling, (Word, Morpheme, Phoneme)): try: if not sibling.precedes(child): insertionpoint = i except: #happens if we can't determine common ancestors pass self.data.insert(insertionpoint, child) return child elif isinstance(child, AbstractSpanAnnotation): #(covers span roles just as well) insertionpoint = len(self.data) try: firstword = child.wrefs(0) except IndexError: #we have no basis to determine an insertionpoint for this child, just append it then return super(AbstractSpanAnnotation,self).append(child, *args, **kwargs) insertionpoint = len(self.data) for i, sibling in enumerate(self.data): if isinstance(sibling, (Word, Morpheme, Phoneme)): try: if not sibling.precedes(firstword): insertionpoint = i except: #happens if we can't determine common ancestors pass return super(AbstractSpanAnnotation,self).insert(insertionpoint, child, *args, **kwargs) else: return super(AbstractSpanAnnotation,self).append(child, *args, **kwargs)
[ "def", "append", "(", "self", ",", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "#Accept Word instances instead of WordReference, references will be automagically used upon serialisation", "if", "isinstance", "(", "child", ",", "(", "Word", ",", "Morpheme", ",", "Phoneme", ")", ")", "and", "WordReference", "in", "self", ".", "ACCEPTED_DATA", ":", "#We don't really append but do an insertion so all references are in proper order", "insertionpoint", "=", "len", "(", "self", ".", "data", ")", "for", "i", ",", "sibling", "in", "enumerate", "(", "self", ".", "data", ")", ":", "if", "isinstance", "(", "sibling", ",", "(", "Word", ",", "Morpheme", ",", "Phoneme", ")", ")", ":", "try", ":", "if", "not", "sibling", ".", "precedes", "(", "child", ")", ":", "insertionpoint", "=", "i", "except", ":", "#happens if we can't determine common ancestors", "pass", "self", ".", "data", ".", "insert", "(", "insertionpoint", ",", "child", ")", "return", "child", "elif", "isinstance", "(", "child", ",", "AbstractSpanAnnotation", ")", ":", "#(covers span roles just as well)", "insertionpoint", "=", "len", "(", "self", ".", "data", ")", "try", ":", "firstword", "=", "child", ".", "wrefs", "(", "0", ")", "except", "IndexError", ":", "#we have no basis to determine an insertionpoint for this child, just append it then", "return", "super", "(", "AbstractSpanAnnotation", ",", "self", ")", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", "insertionpoint", "=", "len", "(", "self", ".", "data", ")", "for", "i", ",", "sibling", "in", "enumerate", "(", "self", ".", "data", ")", ":", "if", "isinstance", "(", "sibling", ",", "(", "Word", ",", "Morpheme", ",", "Phoneme", ")", ")", ":", "try", ":", "if", "not", "sibling", ".", "precedes", "(", "firstword", ")", ":", "insertionpoint", "=", "i", "except", ":", "#happens if we can't determine common ancestors", "pass", "return", "super", "(", "AbstractSpanAnnotation", ",", "self", ")", ".", "insert", "(", "insertionpoint", ",", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "return", "super", "(", "AbstractSpanAnnotation", ",", "self", ")", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]
See :meth:`AbstractElement.append`
[ "See", ":", "meth", ":", "AbstractElement", ".", "append" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4337-L4371
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.setspan
def setspan(self, *args): """Sets the span of the span element anew, erases all data inside. Arguments: *args: Instances of :class:`Word`, :class:`Morpheme` or :class:`Phoneme` """ self.data = [] for child in args: self.append(child)
python
def setspan(self, *args): """Sets the span of the span element anew, erases all data inside. Arguments: *args: Instances of :class:`Word`, :class:`Morpheme` or :class:`Phoneme` """ self.data = [] for child in args: self.append(child)
[ "def", "setspan", "(", "self", ",", "*", "args", ")", ":", "self", ".", "data", "=", "[", "]", "for", "child", "in", "args", ":", "self", ".", "append", "(", "child", ")" ]
Sets the span of the span element anew, erases all data inside. Arguments: *args: Instances of :class:`Word`, :class:`Morpheme` or :class:`Phoneme`
[ "Sets", "the", "span", "of", "the", "span", "element", "anew", "erases", "all", "data", "inside", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4373-L4381
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.hasannotation
def hasannotation(self,Class,set=None): """Returns an integer indicating whether such as annotation exists, and if so, how many. See ``annotations()`` for a description of the parameters.""" return self.count(Class,set,True,default_ignore_annotations)
python
def hasannotation(self,Class,set=None): """Returns an integer indicating whether such as annotation exists, and if so, how many. See ``annotations()`` for a description of the parameters.""" return self.count(Class,set,True,default_ignore_annotations)
[ "def", "hasannotation", "(", "self", ",", "Class", ",", "set", "=", "None", ")", ":", "return", "self", ".", "count", "(", "Class", ",", "set", ",", "True", ",", "default_ignore_annotations", ")" ]
Returns an integer indicating whether such as annotation exists, and if so, how many. See ``annotations()`` for a description of the parameters.
[ "Returns", "an", "integer", "indicating", "whether", "such", "as", "annotation", "exists", "and", "if", "so", "how", "many", ".", "See", "annotations", "()", "for", "a", "description", "of", "the", "parameters", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4386-L4388
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.annotation
def annotation(self, type, set=None): """Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found""" l = list(self.select(type,set,True,default_ignore_annotations)) if len(l) >= 1: return l[0] else: raise NoSuchAnnotation()
python
def annotation(self, type, set=None): """Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found""" l = list(self.select(type,set,True,default_ignore_annotations)) if len(l) >= 1: return l[0] else: raise NoSuchAnnotation()
[ "def", "annotation", "(", "self", ",", "type", ",", "set", "=", "None", ")", ":", "l", "=", "list", "(", "self", ".", "select", "(", "type", ",", "set", ",", "True", ",", "default_ignore_annotations", ")", ")", "if", "len", "(", "l", ")", ">=", "1", ":", "return", "l", "[", "0", "]", "else", ":", "raise", "NoSuchAnnotation", "(", ")" ]
Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found
[ "Will", "return", "a", "**", "single", "**", "annotation", "(", "even", "if", "there", "are", "multiple", ")", ".", "Raises", "a", "NoSuchAnnotation", "exception", "if", "none", "was", "found" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4390-L4396
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation._helper_wrefs
def _helper_wrefs(self, targets, recurse=True): """Internal helper function""" for c in self: if isinstance(c,Word) or isinstance(c,Morpheme) or isinstance(c, Phoneme): targets.append(c) elif isinstance(c,WordReference): try: targets.append(self.doc[c.id]) #try to resolve except KeyError: targets.append(c) #add unresolved elif isinstance(c, AbstractSpanAnnotation) and recurse: #recursion c._helper_wrefs(targets) #pylint: disable=protected-access elif isinstance(c, Correction) and c.auth: #recurse into corrections for e in c: if isinstance(e, AbstractCorrectionChild) and e.auth: for e2 in e: if isinstance(e2, AbstractSpanAnnotation): #recursion e2._helper_wrefs(targets)
python
def _helper_wrefs(self, targets, recurse=True): """Internal helper function""" for c in self: if isinstance(c,Word) or isinstance(c,Morpheme) or isinstance(c, Phoneme): targets.append(c) elif isinstance(c,WordReference): try: targets.append(self.doc[c.id]) #try to resolve except KeyError: targets.append(c) #add unresolved elif isinstance(c, AbstractSpanAnnotation) and recurse: #recursion c._helper_wrefs(targets) #pylint: disable=protected-access elif isinstance(c, Correction) and c.auth: #recurse into corrections for e in c: if isinstance(e, AbstractCorrectionChild) and e.auth: for e2 in e: if isinstance(e2, AbstractSpanAnnotation): #recursion e2._helper_wrefs(targets)
[ "def", "_helper_wrefs", "(", "self", ",", "targets", ",", "recurse", "=", "True", ")", ":", "for", "c", "in", "self", ":", "if", "isinstance", "(", "c", ",", "Word", ")", "or", "isinstance", "(", "c", ",", "Morpheme", ")", "or", "isinstance", "(", "c", ",", "Phoneme", ")", ":", "targets", ".", "append", "(", "c", ")", "elif", "isinstance", "(", "c", ",", "WordReference", ")", ":", "try", ":", "targets", ".", "append", "(", "self", ".", "doc", "[", "c", ".", "id", "]", ")", "#try to resolve", "except", "KeyError", ":", "targets", ".", "append", "(", "c", ")", "#add unresolved", "elif", "isinstance", "(", "c", ",", "AbstractSpanAnnotation", ")", "and", "recurse", ":", "#recursion", "c", ".", "_helper_wrefs", "(", "targets", ")", "#pylint: disable=protected-access", "elif", "isinstance", "(", "c", ",", "Correction", ")", "and", "c", ".", "auth", ":", "#recurse into corrections", "for", "e", "in", "c", ":", "if", "isinstance", "(", "e", ",", "AbstractCorrectionChild", ")", "and", "e", ".", "auth", ":", "for", "e2", "in", "e", ":", "if", "isinstance", "(", "e2", ",", "AbstractSpanAnnotation", ")", ":", "#recursion", "e2", ".", "_helper_wrefs", "(", "targets", ")" ]
Internal helper function
[ "Internal", "helper", "function" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4418-L4437
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.wrefs
def wrefs(self, index = None, recurse=True): """Returns a list of word references, these can be Words but also Morphemes or Phonemes. Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the list of all """ targets =[] self._helper_wrefs(targets, recurse) if index is None: return targets else: return targets[index]
python
def wrefs(self, index = None, recurse=True): """Returns a list of word references, these can be Words but also Morphemes or Phonemes. Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the list of all """ targets =[] self._helper_wrefs(targets, recurse) if index is None: return targets else: return targets[index]
[ "def", "wrefs", "(", "self", ",", "index", "=", "None", ",", "recurse", "=", "True", ")", ":", "targets", "=", "[", "]", "self", ".", "_helper_wrefs", "(", "targets", ",", "recurse", ")", "if", "index", "is", "None", ":", "return", "targets", "else", ":", "return", "targets", "[", "index", "]" ]
Returns a list of word references, these can be Words but also Morphemes or Phonemes. Arguments: index (int or None): If set to an integer, will retrieve and return the n'th element (starting at 0) instead of returning the list of all
[ "Returns", "a", "list", "of", "word", "references", "these", "can", "be", "Words", "but", "also", "Morphemes", "or", "Phonemes", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4439-L4450
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.addtoindex
def addtoindex(self,norecurse=None): """Makes sure this element (and all subelements), are properly added to the index""" if not norecurse: norecurse = (Word, Morpheme, Phoneme) if self.id: self.doc.index[self.id] = self for e in self.data: if all([not isinstance(e, C) for C in norecurse]): try: e.addtoindex(norecurse) except AttributeError: pass
python
def addtoindex(self,norecurse=None): """Makes sure this element (and all subelements), are properly added to the index""" if not norecurse: norecurse = (Word, Morpheme, Phoneme) if self.id: self.doc.index[self.id] = self for e in self.data: if all([not isinstance(e, C) for C in norecurse]): try: e.addtoindex(norecurse) except AttributeError: pass
[ "def", "addtoindex", "(", "self", ",", "norecurse", "=", "None", ")", ":", "if", "not", "norecurse", ":", "norecurse", "=", "(", "Word", ",", "Morpheme", ",", "Phoneme", ")", "if", "self", ".", "id", ":", "self", ".", "doc", ".", "index", "[", "self", ".", "id", "]", "=", "self", "for", "e", "in", "self", ".", "data", ":", "if", "all", "(", "[", "not", "isinstance", "(", "e", ",", "C", ")", "for", "C", "in", "norecurse", "]", ")", ":", "try", ":", "e", ".", "addtoindex", "(", "norecurse", ")", "except", "AttributeError", ":", "pass" ]
Makes sure this element (and all subelements), are properly added to the index
[ "Makes", "sure", "this", "element", "(", "and", "all", "subelements", ")", "are", "properly", "added", "to", "the", "index" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4452-L4462
proycon/pynlpl
pynlpl/formats/folia.py
AbstractSpanAnnotation.copychildren
def copychildren(self, newdoc=None, idsuffix=""): """Generator creating a deep copy of the children of this element. If idsuffix is a string, if set to True, a random idsuffix will be generated including a random 32-bit hash""" if idsuffix is True: idsuffix = ".copy." + "%08x" % random.getrandbits(32) #random 32-bit hash for each copy, same one will be reused for all children for c in self: if isinstance(c, Word): yield WordReference(newdoc, id=c.id) else: yield c.copy(newdoc,idsuffix)
python
def copychildren(self, newdoc=None, idsuffix=""): """Generator creating a deep copy of the children of this element. If idsuffix is a string, if set to True, a random idsuffix will be generated including a random 32-bit hash""" if idsuffix is True: idsuffix = ".copy." + "%08x" % random.getrandbits(32) #random 32-bit hash for each copy, same one will be reused for all children for c in self: if isinstance(c, Word): yield WordReference(newdoc, id=c.id) else: yield c.copy(newdoc,idsuffix)
[ "def", "copychildren", "(", "self", ",", "newdoc", "=", "None", ",", "idsuffix", "=", "\"\"", ")", ":", "if", "idsuffix", "is", "True", ":", "idsuffix", "=", "\".copy.\"", "+", "\"%08x\"", "%", "random", ".", "getrandbits", "(", "32", ")", "#random 32-bit hash for each copy, same one will be reused for all children", "for", "c", "in", "self", ":", "if", "isinstance", "(", "c", ",", "Word", ")", ":", "yield", "WordReference", "(", "newdoc", ",", "id", "=", "c", ".", "id", ")", "else", ":", "yield", "c", ".", "copy", "(", "newdoc", ",", "idsuffix", ")" ]
Generator creating a deep copy of the children of this element. If idsuffix is a string, if set to True, a random idsuffix will be generated including a random 32-bit hash
[ "Generator", "creating", "a", "deep", "copy", "of", "the", "children", "of", "this", "element", ".", "If", "idsuffix", "is", "a", "string", "if", "set", "to", "True", "a", "random", "idsuffix", "will", "be", "generated", "including", "a", "random", "32", "-", "bit", "hash" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4465-L4472
proycon/pynlpl
pynlpl/formats/folia.py
AbstractAnnotationLayer.xml
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" if self.set is False or self.set is None: if len(self.data) == 0: #just skip if there are no children return None else: raise ValueError("No set specified or derivable for annotation layer " + self.__class__.__name__) return super(AbstractAnnotationLayer, self).xml(attribs, elements, skipchildren)
python
def xml(self, attribs = None,elements = None, skipchildren = False): """See :meth:`AbstractElement.xml`""" if self.set is False or self.set is None: if len(self.data) == 0: #just skip if there are no children return None else: raise ValueError("No set specified or derivable for annotation layer " + self.__class__.__name__) return super(AbstractAnnotationLayer, self).xml(attribs, elements, skipchildren)
[ "def", "xml", "(", "self", ",", "attribs", "=", "None", ",", "elements", "=", "None", ",", "skipchildren", "=", "False", ")", ":", "if", "self", ".", "set", "is", "False", "or", "self", ".", "set", "is", "None", ":", "if", "len", "(", "self", ".", "data", ")", "==", "0", ":", "#just skip if there are no children", "return", "None", "else", ":", "raise", "ValueError", "(", "\"No set specified or derivable for annotation layer \"", "+", "self", ".", "__class__", ".", "__name__", ")", "return", "super", "(", "AbstractAnnotationLayer", ",", "self", ")", ".", "xml", "(", "attribs", ",", "elements", ",", "skipchildren", ")" ]
See :meth:`AbstractElement.xml`
[ "See", ":", "meth", ":", "AbstractElement", ".", "xml" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4512-L4519
proycon/pynlpl
pynlpl/formats/folia.py
AbstractAnnotationLayer.append
def append(self, child, *args, **kwargs): """See :meth:`AbstractElement.append`""" #if no set is associated with the layer yet, we learn it from span annotation elements that are added if self.set is False or self.set is None: if inspect.isclass(child): if issubclass(child,AbstractSpanAnnotation): if 'set' in kwargs: self.set = kwargs['set'] elif isinstance(child, AbstractSpanAnnotation): if child.set: self.set = child.set elif isinstance(child, Correction): #descend into corrections to find the proper set for this layer (derived from span annotation elements) for e in itertools.chain( child.new(), child.original(), child.suggestions() ): if isinstance(e, AbstractSpanAnnotation) and e.set: self.set = e.set break return super(AbstractAnnotationLayer, self).append(child, *args, **kwargs)
python
def append(self, child, *args, **kwargs): """See :meth:`AbstractElement.append`""" #if no set is associated with the layer yet, we learn it from span annotation elements that are added if self.set is False or self.set is None: if inspect.isclass(child): if issubclass(child,AbstractSpanAnnotation): if 'set' in kwargs: self.set = kwargs['set'] elif isinstance(child, AbstractSpanAnnotation): if child.set: self.set = child.set elif isinstance(child, Correction): #descend into corrections to find the proper set for this layer (derived from span annotation elements) for e in itertools.chain( child.new(), child.original(), child.suggestions() ): if isinstance(e, AbstractSpanAnnotation) and e.set: self.set = e.set break return super(AbstractAnnotationLayer, self).append(child, *args, **kwargs)
[ "def", "append", "(", "self", ",", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "#if no set is associated with the layer yet, we learn it from span annotation elements that are added", "if", "self", ".", "set", "is", "False", "or", "self", ".", "set", "is", "None", ":", "if", "inspect", ".", "isclass", "(", "child", ")", ":", "if", "issubclass", "(", "child", ",", "AbstractSpanAnnotation", ")", ":", "if", "'set'", "in", "kwargs", ":", "self", ".", "set", "=", "kwargs", "[", "'set'", "]", "elif", "isinstance", "(", "child", ",", "AbstractSpanAnnotation", ")", ":", "if", "child", ".", "set", ":", "self", ".", "set", "=", "child", ".", "set", "elif", "isinstance", "(", "child", ",", "Correction", ")", ":", "#descend into corrections to find the proper set for this layer (derived from span annotation elements)", "for", "e", "in", "itertools", ".", "chain", "(", "child", ".", "new", "(", ")", ",", "child", ".", "original", "(", ")", ",", "child", ".", "suggestions", "(", ")", ")", ":", "if", "isinstance", "(", "e", ",", "AbstractSpanAnnotation", ")", "and", "e", ".", "set", ":", "self", ".", "set", "=", "e", ".", "set", "break", "return", "super", "(", "AbstractAnnotationLayer", ",", "self", ")", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]
See :meth:`AbstractElement.append`
[ "See", ":", "meth", ":", "AbstractElement", ".", "append" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4521-L4539
proycon/pynlpl
pynlpl/formats/folia.py
AbstractAnnotationLayer.alternatives
def alternatives(self, Class=None, set=None): """Generator over alternatives, either all or only of a specific annotation type, and possibly restrained also by set. Arguments: * ``Class`` - The Class you want to retrieve (e.g. PosAnnotation). Or set to None to select all alternatives regardless of what type they are. * ``set`` - The set you want to retrieve (defaults to None, which selects irregardless of set) Returns: Generator over Alternative elements """ for e in self.select(AlternativeLayers,None, True, ['Original','Suggestion']): #pylint: disable=too-many-nested-blocks if Class is None: yield e elif len(e) >= 1: #child elements? for e2 in e: try: if isinstance(e2, Class): try: if set is None or e2.set == set: yield e #not e2 break #yield an alternative only once (in case there are multiple matches) except AttributeError: continue except AttributeError: continue
python
def alternatives(self, Class=None, set=None): """Generator over alternatives, either all or only of a specific annotation type, and possibly restrained also by set. Arguments: * ``Class`` - The Class you want to retrieve (e.g. PosAnnotation). Or set to None to select all alternatives regardless of what type they are. * ``set`` - The set you want to retrieve (defaults to None, which selects irregardless of set) Returns: Generator over Alternative elements """ for e in self.select(AlternativeLayers,None, True, ['Original','Suggestion']): #pylint: disable=too-many-nested-blocks if Class is None: yield e elif len(e) >= 1: #child elements? for e2 in e: try: if isinstance(e2, Class): try: if set is None or e2.set == set: yield e #not e2 break #yield an alternative only once (in case there are multiple matches) except AttributeError: continue except AttributeError: continue
[ "def", "alternatives", "(", "self", ",", "Class", "=", "None", ",", "set", "=", "None", ")", ":", "for", "e", "in", "self", ".", "select", "(", "AlternativeLayers", ",", "None", ",", "True", ",", "[", "'Original'", ",", "'Suggestion'", "]", ")", ":", "#pylint: disable=too-many-nested-blocks", "if", "Class", "is", "None", ":", "yield", "e", "elif", "len", "(", "e", ")", ">=", "1", ":", "#child elements?", "for", "e2", "in", "e", ":", "try", ":", "if", "isinstance", "(", "e2", ",", "Class", ")", ":", "try", ":", "if", "set", "is", "None", "or", "e2", ".", "set", "==", "set", ":", "yield", "e", "#not e2", "break", "#yield an alternative only once (in case there are multiple matches)", "except", "AttributeError", ":", "continue", "except", "AttributeError", ":", "continue" ]
Generator over alternatives, either all or only of a specific annotation type, and possibly restrained also by set. Arguments: * ``Class`` - The Class you want to retrieve (e.g. PosAnnotation). Or set to None to select all alternatives regardless of what type they are. * ``set`` - The set you want to retrieve (defaults to None, which selects irregardless of set) Returns: Generator over Alternative elements
[ "Generator", "over", "alternatives", "either", "all", "or", "only", "of", "a", "specific", "annotation", "type", "and", "possibly", "restrained", "also", "by", "set", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4574-L4599
proycon/pynlpl
pynlpl/formats/folia.py
AbstractAnnotationLayer.findspan
def findspan(self, *words): """Returns the span element which spans over the specified words or morphemes. See also: :meth:`Word.findspans` """ for span in self.select(AbstractSpanAnnotation,None,True): if tuple(span.wrefs()) == words: return span raise NoSuchAnnotation
python
def findspan(self, *words): """Returns the span element which spans over the specified words or morphemes. See also: :meth:`Word.findspans` """ for span in self.select(AbstractSpanAnnotation,None,True): if tuple(span.wrefs()) == words: return span raise NoSuchAnnotation
[ "def", "findspan", "(", "self", ",", "*", "words", ")", ":", "for", "span", "in", "self", ".", "select", "(", "AbstractSpanAnnotation", ",", "None", ",", "True", ")", ":", "if", "tuple", "(", "span", ".", "wrefs", "(", ")", ")", "==", "words", ":", "return", "span", "raise", "NoSuchAnnotation" ]
Returns the span element which spans over the specified words or morphemes. See also: :meth:`Word.findspans`
[ "Returns", "the", "span", "element", "which", "spans", "over", "the", "specified", "words", "or", "morphemes", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4601-L4611
proycon/pynlpl
pynlpl/formats/folia.py
AbstractAnnotationLayer.relaxng
def relaxng(cls, includechildren=True,extraattribs = None, extraelements=None, origclass = None): """Returns a RelaxNG definition for this element (as an XML element (lxml.etree) rather than a string)""" E = ElementMaker(namespace="http://relaxng.org/ns/structure/1.0",nsmap={None:'http://relaxng.org/ns/structure/1.0' , 'folia': "http://ilk.uvt.nl/folia", 'xml' : "http://www.w3.org/XML/1998/namespace",'a':"http://relaxng.org/ns/annotation/0.9" }) if not extraattribs: extraattribs = [] extraattribs.append(E.optional(E.attribute(E.text(), name='set')) ) return AbstractElement.relaxng(includechildren, extraattribs, extraelements, cls)
python
def relaxng(cls, includechildren=True,extraattribs = None, extraelements=None, origclass = None): """Returns a RelaxNG definition for this element (as an XML element (lxml.etree) rather than a string)""" E = ElementMaker(namespace="http://relaxng.org/ns/structure/1.0",nsmap={None:'http://relaxng.org/ns/structure/1.0' , 'folia': "http://ilk.uvt.nl/folia", 'xml' : "http://www.w3.org/XML/1998/namespace",'a':"http://relaxng.org/ns/annotation/0.9" }) if not extraattribs: extraattribs = [] extraattribs.append(E.optional(E.attribute(E.text(), name='set')) ) return AbstractElement.relaxng(includechildren, extraattribs, extraelements, cls)
[ "def", "relaxng", "(", "cls", ",", "includechildren", "=", "True", ",", "extraattribs", "=", "None", ",", "extraelements", "=", "None", ",", "origclass", "=", "None", ")", ":", "E", "=", "ElementMaker", "(", "namespace", "=", "\"http://relaxng.org/ns/structure/1.0\"", ",", "nsmap", "=", "{", "None", ":", "'http://relaxng.org/ns/structure/1.0'", ",", "'folia'", ":", "\"http://ilk.uvt.nl/folia\"", ",", "'xml'", ":", "\"http://www.w3.org/XML/1998/namespace\"", ",", "'a'", ":", "\"http://relaxng.org/ns/annotation/0.9\"", "}", ")", "if", "not", "extraattribs", ":", "extraattribs", "=", "[", "]", "extraattribs", ".", "append", "(", "E", ".", "optional", "(", "E", ".", "attribute", "(", "E", ".", "text", "(", ")", ",", "name", "=", "'set'", ")", ")", ")", "return", "AbstractElement", ".", "relaxng", "(", "includechildren", ",", "extraattribs", ",", "extraelements", ",", "cls", ")" ]
Returns a RelaxNG definition for this element (as an XML element (lxml.etree) rather than a string)
[ "Returns", "a", "RelaxNG", "definition", "for", "this", "element", "(", "as", "an", "XML", "element", "(", "lxml", ".", "etree", ")", "rather", "than", "a", "string", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4614-L4620
proycon/pynlpl
pynlpl/formats/folia.py
Correction.hasnew
def hasnew(self,allowempty=False): """Does the correction define new corrected annotations?""" for e in self.select(New,None,False, False): if not allowempty and len(e) == 0: continue return True return False
python
def hasnew(self,allowempty=False): """Does the correction define new corrected annotations?""" for e in self.select(New,None,False, False): if not allowempty and len(e) == 0: continue return True return False
[ "def", "hasnew", "(", "self", ",", "allowempty", "=", "False", ")", ":", "for", "e", "in", "self", ".", "select", "(", "New", ",", "None", ",", "False", ",", "False", ")", ":", "if", "not", "allowempty", "and", "len", "(", "e", ")", "==", "0", ":", "continue", "return", "True", "return", "False" ]
Does the correction define new corrected annotations?
[ "Does", "the", "correction", "define", "new", "corrected", "annotations?" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4982-L4987
proycon/pynlpl
pynlpl/formats/folia.py
Correction.hasoriginal
def hasoriginal(self,allowempty=False): """Does the correction record the old annotations prior to correction?""" for e in self.select(Original,None,False, False): if not allowempty and len(e) == 0: continue return True return False
python
def hasoriginal(self,allowempty=False): """Does the correction record the old annotations prior to correction?""" for e in self.select(Original,None,False, False): if not allowempty and len(e) == 0: continue return True return False
[ "def", "hasoriginal", "(", "self", ",", "allowempty", "=", "False", ")", ":", "for", "e", "in", "self", ".", "select", "(", "Original", ",", "None", ",", "False", ",", "False", ")", ":", "if", "not", "allowempty", "and", "len", "(", "e", ")", "==", "0", ":", "continue", "return", "True", "return", "False" ]
Does the correction record the old annotations prior to correction?
[ "Does", "the", "correction", "record", "the", "old", "annotations", "prior", "to", "correction?" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4989-L4994
proycon/pynlpl
pynlpl/formats/folia.py
Correction.hascurrent
def hascurrent(self, allowempty=False): """Does the correction record the current authoritative annotation (needed only in a structural context when suggestions are proposed)""" for e in self.select(Current,None,False, False): if not allowempty and len(e) == 0: continue return True return False
python
def hascurrent(self, allowempty=False): """Does the correction record the current authoritative annotation (needed only in a structural context when suggestions are proposed)""" for e in self.select(Current,None,False, False): if not allowempty and len(e) == 0: continue return True return False
[ "def", "hascurrent", "(", "self", ",", "allowempty", "=", "False", ")", ":", "for", "e", "in", "self", ".", "select", "(", "Current", ",", "None", ",", "False", ",", "False", ")", ":", "if", "not", "allowempty", "and", "len", "(", "e", ")", "==", "0", ":", "continue", "return", "True", "return", "False" ]
Does the correction record the current authoritative annotation (needed only in a structural context when suggestions are proposed)
[ "Does", "the", "correction", "record", "the", "current", "authoritative", "annotation", "(", "needed", "only", "in", "a", "structural", "context", "when", "suggestions", "are", "proposed", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L4996-L5001
proycon/pynlpl
pynlpl/formats/folia.py
Correction.hassuggestions
def hassuggestions(self,allowempty=False): """Does the correction propose suggestions for correction?""" for e in self.select(Suggestion,None,False, False): if not allowempty and len(e) == 0: continue return True return False
python
def hassuggestions(self,allowempty=False): """Does the correction propose suggestions for correction?""" for e in self.select(Suggestion,None,False, False): if not allowempty and len(e) == 0: continue return True return False
[ "def", "hassuggestions", "(", "self", ",", "allowempty", "=", "False", ")", ":", "for", "e", "in", "self", ".", "select", "(", "Suggestion", ",", "None", ",", "False", ",", "False", ")", ":", "if", "not", "allowempty", "and", "len", "(", "e", ")", "==", "0", ":", "continue", "return", "True", "return", "False" ]
Does the correction propose suggestions for correction?
[ "Does", "the", "correction", "propose", "suggestions", "for", "correction?" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5003-L5008
proycon/pynlpl
pynlpl/formats/folia.py
Correction.textcontent
def textcontent(self, cls='current', correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.textcontent`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return e.textcontent(cls,correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return e.textcontent(cls,correctionhandling) raise NoSuchText
python
def textcontent(self, cls='current', correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.textcontent`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return e.textcontent(cls,correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return e.textcontent(cls,correctionhandling) raise NoSuchText
[ "def", "textcontent", "(", "self", ",", "cls", "=", "'current'", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ")", ":", "if", "cls", "==", "'original'", ":", "correctionhandling", "=", "CorrectionHandling", ".", "ORIGINAL", "#backward compatibility", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "CURRENT", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "New", ")", "or", "isinstance", "(", "e", ",", "Current", ")", ":", "return", "e", ".", "textcontent", "(", "cls", ",", "correctionhandling", ")", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "ORIGINAL", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "Original", ")", ":", "return", "e", ".", "textcontent", "(", "cls", ",", "correctionhandling", ")", "raise", "NoSuchText" ]
See :meth:`AbstractElement.textcontent`
[ "See", ":", "meth", ":", "AbstractElement", ".", "textcontent" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5010-L5021
proycon/pynlpl
pynlpl/formats/folia.py
Correction.phoncontent
def phoncontent(self, cls='current', correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.phoncontent`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return e.phoncontent(cls, correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return e.phoncontent(cls, correctionhandling) raise NoSuchPhon
python
def phoncontent(self, cls='current', correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.phoncontent`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return e.phoncontent(cls, correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return e.phoncontent(cls, correctionhandling) raise NoSuchPhon
[ "def", "phoncontent", "(", "self", ",", "cls", "=", "'current'", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ")", ":", "if", "cls", "==", "'original'", ":", "correctionhandling", "=", "CorrectionHandling", ".", "ORIGINAL", "#backward compatibility", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "CURRENT", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "New", ")", "or", "isinstance", "(", "e", ",", "Current", ")", ":", "return", "e", ".", "phoncontent", "(", "cls", ",", "correctionhandling", ")", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "ORIGINAL", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "Original", ")", ":", "return", "e", ".", "phoncontent", "(", "cls", ",", "correctionhandling", ")", "raise", "NoSuchPhon" ]
See :meth:`AbstractElement.phoncontent`
[ "See", ":", "meth", ":", "AbstractElement", ".", "phoncontent" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5024-L5035
proycon/pynlpl
pynlpl/formats/folia.py
Correction.hastext
def hastext(self, cls='current',strict=True, correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.hastext`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return e.hastext(cls,strict, correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return e.hastext(cls,strict, correctionhandling) return False
python
def hastext(self, cls='current',strict=True, correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.hastext`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return e.hastext(cls,strict, correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return e.hastext(cls,strict, correctionhandling) return False
[ "def", "hastext", "(", "self", ",", "cls", "=", "'current'", ",", "strict", "=", "True", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ")", ":", "if", "cls", "==", "'original'", ":", "correctionhandling", "=", "CorrectionHandling", ".", "ORIGINAL", "#backward compatibility", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "CURRENT", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "New", ")", "or", "isinstance", "(", "e", ",", "Current", ")", ":", "return", "e", ".", "hastext", "(", "cls", ",", "strict", ",", "correctionhandling", ")", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "ORIGINAL", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "Original", ")", ":", "return", "e", ".", "hastext", "(", "cls", ",", "strict", ",", "correctionhandling", ")", "return", "False" ]
See :meth:`AbstractElement.hastext`
[ "See", ":", "meth", ":", "AbstractElement", ".", "hastext" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5038-L5049
proycon/pynlpl
pynlpl/formats/folia.py
Correction.text
def text(self, cls = 'current', retaintokenisation=False, previousdelimiter="",strict=False, correctionhandling=CorrectionHandling.CURRENT, normalize_spaces=False): """See :meth:`AbstractElement.text`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): s = previousdelimiter + e.text(cls, retaintokenisation,"", strict, correctionhandling) if normalize_spaces: return norm_spaces(s) else: return s if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): s = previousdelimiter + e.text(cls, retaintokenisation,"", strict, correctionhandling) if normalize_spaces: return norm_spaces(s) else: return s raise NoSuchText
python
def text(self, cls = 'current', retaintokenisation=False, previousdelimiter="",strict=False, correctionhandling=CorrectionHandling.CURRENT, normalize_spaces=False): """See :meth:`AbstractElement.text`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): s = previousdelimiter + e.text(cls, retaintokenisation,"", strict, correctionhandling) if normalize_spaces: return norm_spaces(s) else: return s if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): s = previousdelimiter + e.text(cls, retaintokenisation,"", strict, correctionhandling) if normalize_spaces: return norm_spaces(s) else: return s raise NoSuchText
[ "def", "text", "(", "self", ",", "cls", "=", "'current'", ",", "retaintokenisation", "=", "False", ",", "previousdelimiter", "=", "\"\"", ",", "strict", "=", "False", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ",", "normalize_spaces", "=", "False", ")", ":", "if", "cls", "==", "'original'", ":", "correctionhandling", "=", "CorrectionHandling", ".", "ORIGINAL", "#backward compatibility", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "CURRENT", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "New", ")", "or", "isinstance", "(", "e", ",", "Current", ")", ":", "s", "=", "previousdelimiter", "+", "e", ".", "text", "(", "cls", ",", "retaintokenisation", ",", "\"\"", ",", "strict", ",", "correctionhandling", ")", "if", "normalize_spaces", ":", "return", "norm_spaces", "(", "s", ")", "else", ":", "return", "s", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "ORIGINAL", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "Original", ")", ":", "s", "=", "previousdelimiter", "+", "e", ".", "text", "(", "cls", ",", "retaintokenisation", ",", "\"\"", ",", "strict", ",", "correctionhandling", ")", "if", "normalize_spaces", ":", "return", "norm_spaces", "(", "s", ")", "else", ":", "return", "s", "raise", "NoSuchText" ]
See :meth:`AbstractElement.text`
[ "See", ":", "meth", ":", "AbstractElement", ".", "text" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5051-L5070
proycon/pynlpl
pynlpl/formats/folia.py
Correction.phon
def phon(self, cls = 'current', previousdelimiter="",strict=False, correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.phon`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return previousdelimiter + e.phon(cls, "", strict, correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return previousdelimiter + e.phon(cls, "", correctionhandling) raise NoSuchPhon
python
def phon(self, cls = 'current', previousdelimiter="",strict=False, correctionhandling=CorrectionHandling.CURRENT): """See :meth:`AbstractElement.phon`""" if cls == 'original': correctionhandling = CorrectionHandling.ORIGINAL #backward compatibility if correctionhandling in (CorrectionHandling.CURRENT, CorrectionHandling.EITHER): for e in self: if isinstance(e, New) or isinstance(e, Current): return previousdelimiter + e.phon(cls, "", strict, correctionhandling) if correctionhandling in (CorrectionHandling.ORIGINAL, CorrectionHandling.EITHER): for e in self: if isinstance(e, Original): return previousdelimiter + e.phon(cls, "", correctionhandling) raise NoSuchPhon
[ "def", "phon", "(", "self", ",", "cls", "=", "'current'", ",", "previousdelimiter", "=", "\"\"", ",", "strict", "=", "False", ",", "correctionhandling", "=", "CorrectionHandling", ".", "CURRENT", ")", ":", "if", "cls", "==", "'original'", ":", "correctionhandling", "=", "CorrectionHandling", ".", "ORIGINAL", "#backward compatibility", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "CURRENT", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "New", ")", "or", "isinstance", "(", "e", ",", "Current", ")", ":", "return", "previousdelimiter", "+", "e", ".", "phon", "(", "cls", ",", "\"\"", ",", "strict", ",", "correctionhandling", ")", "if", "correctionhandling", "in", "(", "CorrectionHandling", ".", "ORIGINAL", ",", "CorrectionHandling", ".", "EITHER", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "Original", ")", ":", "return", "previousdelimiter", "+", "e", ".", "phon", "(", "cls", ",", "\"\"", ",", "correctionhandling", ")", "raise", "NoSuchPhon" ]
See :meth:`AbstractElement.phon`
[ "See", ":", "meth", ":", "AbstractElement", ".", "phon" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5085-L5096
proycon/pynlpl
pynlpl/formats/folia.py
Correction.gettextdelimiter
def gettextdelimiter(self, retaintokenisation=False): """See :meth:`AbstractElement.gettextdelimiter`""" for e in self: if isinstance(e, New) or isinstance(e, Current): return e.gettextdelimiter(retaintokenisation) return ""
python
def gettextdelimiter(self, retaintokenisation=False): """See :meth:`AbstractElement.gettextdelimiter`""" for e in self: if isinstance(e, New) or isinstance(e, Current): return e.gettextdelimiter(retaintokenisation) return ""
[ "def", "gettextdelimiter", "(", "self", ",", "retaintokenisation", "=", "False", ")", ":", "for", "e", "in", "self", ":", "if", "isinstance", "(", "e", ",", "New", ")", "or", "isinstance", "(", "e", ",", "Current", ")", ":", "return", "e", ".", "gettextdelimiter", "(", "retaintokenisation", ")", "return", "\"\"" ]
See :meth:`AbstractElement.gettextdelimiter`
[ "See", ":", "meth", ":", "AbstractElement", ".", "gettextdelimiter" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5098-L5103
proycon/pynlpl
pynlpl/formats/folia.py
Correction.new
def new(self,index = None): """Get the new corrected annotation. This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation` """ if index is None: try: return next(self.select(New,None,False)) except StopIteration: raise NoSuchAnnotation else: for e in self.select(New,None,False): return e[index] raise NoSuchAnnotation
python
def new(self,index = None): """Get the new corrected annotation. This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation` """ if index is None: try: return next(self.select(New,None,False)) except StopIteration: raise NoSuchAnnotation else: for e in self.select(New,None,False): return e[index] raise NoSuchAnnotation
[ "def", "new", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "try", ":", "return", "next", "(", "self", ".", "select", "(", "New", ",", "None", ",", "False", ")", ")", "except", "StopIteration", ":", "raise", "NoSuchAnnotation", "else", ":", "for", "e", "in", "self", ".", "select", "(", "New", ",", "None", ",", "False", ")", ":", "return", "e", "[", "index", "]", "raise", "NoSuchAnnotation" ]
Get the new corrected annotation. This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation`
[ "Get", "the", "new", "corrected", "annotation", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5106-L5126
proycon/pynlpl
pynlpl/formats/folia.py
Correction.original
def original(self,index=None): """Get the old annotation prior to correction. This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation` """ if index is None: try: return next(self.select(Original,None,False, False)) except StopIteration: raise NoSuchAnnotation else: for e in self.select(Original,None,False, False): return e[index] raise NoSuchAnnotation
python
def original(self,index=None): """Get the old annotation prior to correction. This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation` """ if index is None: try: return next(self.select(Original,None,False, False)) except StopIteration: raise NoSuchAnnotation else: for e in self.select(Original,None,False, False): return e[index] raise NoSuchAnnotation
[ "def", "original", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "try", ":", "return", "next", "(", "self", ".", "select", "(", "Original", ",", "None", ",", "False", ",", "False", ")", ")", "except", "StopIteration", ":", "raise", "NoSuchAnnotation", "else", ":", "for", "e", "in", "self", ".", "select", "(", "Original", ",", "None", ",", "False", ",", "False", ")", ":", "return", "e", "[", "index", "]", "raise", "NoSuchAnnotation" ]
Get the old annotation prior to correction. This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation`
[ "Get", "the", "old", "annotation", "prior", "to", "correction", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5128-L5147
proycon/pynlpl
pynlpl/formats/folia.py
Correction.current
def current(self,index=None): """Get the current authoritative annotation (used with suggestions in a structural context) This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation` """ if index is None: try: return next(self.select(Current,None,False)) except StopIteration: raise NoSuchAnnotation else: for e in self.select(Current,None,False): return e[index] raise NoSuchAnnotation
python
def current(self,index=None): """Get the current authoritative annotation (used with suggestions in a structural context) This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation` """ if index is None: try: return next(self.select(Current,None,False)) except StopIteration: raise NoSuchAnnotation else: for e in self.select(Current,None,False): return e[index] raise NoSuchAnnotation
[ "def", "current", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "try", ":", "return", "next", "(", "self", ".", "select", "(", "Current", ",", "None", ",", "False", ")", ")", "except", "StopIteration", ":", "raise", "NoSuchAnnotation", "else", ":", "for", "e", "in", "self", ".", "select", "(", "Current", ",", "None", ",", "False", ")", ":", "return", "e", "[", "index", "]", "raise", "NoSuchAnnotation" ]
Get the current authoritative annotation (used with suggestions in a structural context) This returns only one annotation if multiple exist, use `index` to select another in the sequence. Returns: an annotation element (:class:`AbstractElement`) Raises: :class:`NoSuchAnnotation`
[ "Get", "the", "current", "authoritative", "annotation", "(", "used", "with", "suggestions", "in", "a", "structural", "context", ")" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5149-L5168
proycon/pynlpl
pynlpl/formats/folia.py
Correction.suggestions
def suggestions(self,index=None): """Get suggestions for correction. Yields: :class:`Suggestion` element that encapsulate the suggested annotations (if index is ``None``, default) Returns: a :class:`Suggestion` element that encapsulate the suggested annotations (if index is set) Raises: :class:`IndexError` """ if index is None: return self.select(Suggestion,None,False, False) else: for i, e in enumerate(self.select(Suggestion,None,False, False)): if index == i: return e raise IndexError
python
def suggestions(self,index=None): """Get suggestions for correction. Yields: :class:`Suggestion` element that encapsulate the suggested annotations (if index is ``None``, default) Returns: a :class:`Suggestion` element that encapsulate the suggested annotations (if index is set) Raises: :class:`IndexError` """ if index is None: return self.select(Suggestion,None,False, False) else: for i, e in enumerate(self.select(Suggestion,None,False, False)): if index == i: return e raise IndexError
[ "def", "suggestions", "(", "self", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "return", "self", ".", "select", "(", "Suggestion", ",", "None", ",", "False", ",", "False", ")", "else", ":", "for", "i", ",", "e", "in", "enumerate", "(", "self", ".", "select", "(", "Suggestion", ",", "None", ",", "False", ",", "False", ")", ")", ":", "if", "index", "==", "i", ":", "return", "e", "raise", "IndexError" ]
Get suggestions for correction. Yields: :class:`Suggestion` element that encapsulate the suggested annotations (if index is ``None``, default) Returns: a :class:`Suggestion` element that encapsulate the suggested annotations (if index is set) Raises: :class:`IndexError`
[ "Get", "suggestions", "for", "correction", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5170-L5188
proycon/pynlpl
pynlpl/formats/folia.py
External.select
def select(self, Class, set=None, recursive=True, ignore=True, node=None): """See :meth:`AbstractElement.select`""" if self.include: return self.subdoc.data[0].select(Class,set,recursive, ignore, node) #pass it on to the text node of the subdoc else: return iter([])
python
def select(self, Class, set=None, recursive=True, ignore=True, node=None): """See :meth:`AbstractElement.select`""" if self.include: return self.subdoc.data[0].select(Class,set,recursive, ignore, node) #pass it on to the text node of the subdoc else: return iter([])
[ "def", "select", "(", "self", ",", "Class", ",", "set", "=", "None", ",", "recursive", "=", "True", ",", "ignore", "=", "True", ",", "node", "=", "None", ")", ":", "if", "self", ".", "include", ":", "return", "self", ".", "subdoc", ".", "data", "[", "0", "]", ".", "select", "(", "Class", ",", "set", ",", "recursive", ",", "ignore", ",", "node", ")", "#pass it on to the text node of the subdoc", "else", ":", "return", "iter", "(", "[", "]", ")" ]
See :meth:`AbstractElement.select`
[ "See", ":", "meth", ":", "AbstractElement", ".", "select" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5353-L5358
proycon/pynlpl
pynlpl/formats/folia.py
WordReference.xml
def xml(self, attribs = None,elements = None, skipchildren = False): """Serialises the FoLiA element to XML, by returning an XML Element (in lxml.etree) for this element and all its children. For string output, consider the xmlstring() method instead.""" E = ElementMaker(namespace=NSFOLIA,nsmap={None: NSFOLIA, 'xml' : "http://www.w3.org/XML/1998/namespace"}) if not attribs: attribs = {} if not elements: elements = [] if self.id: attribs['id'] = self.id try: w = self.doc[self.id] attribs['t'] = w.text() except KeyError: pass e = makeelement(E, '{' + NSFOLIA + '}' + self.XMLTAG, **attribs) return e
python
def xml(self, attribs = None,elements = None, skipchildren = False): """Serialises the FoLiA element to XML, by returning an XML Element (in lxml.etree) for this element and all its children. For string output, consider the xmlstring() method instead.""" E = ElementMaker(namespace=NSFOLIA,nsmap={None: NSFOLIA, 'xml' : "http://www.w3.org/XML/1998/namespace"}) if not attribs: attribs = {} if not elements: elements = [] if self.id: attribs['id'] = self.id try: w = self.doc[self.id] attribs['t'] = w.text() except KeyError: pass e = makeelement(E, '{' + NSFOLIA + '}' + self.XMLTAG, **attribs) return e
[ "def", "xml", "(", "self", ",", "attribs", "=", "None", ",", "elements", "=", "None", ",", "skipchildren", "=", "False", ")", ":", "E", "=", "ElementMaker", "(", "namespace", "=", "NSFOLIA", ",", "nsmap", "=", "{", "None", ":", "NSFOLIA", ",", "'xml'", ":", "\"http://www.w3.org/XML/1998/namespace\"", "}", ")", "if", "not", "attribs", ":", "attribs", "=", "{", "}", "if", "not", "elements", ":", "elements", "=", "[", "]", "if", "self", ".", "id", ":", "attribs", "[", "'id'", "]", "=", "self", ".", "id", "try", ":", "w", "=", "self", ".", "doc", "[", "self", ".", "id", "]", "attribs", "[", "'t'", "]", "=", "w", ".", "text", "(", ")", "except", "KeyError", ":", "pass", "e", "=", "makeelement", "(", "E", ",", "'{'", "+", "NSFOLIA", "+", "'}'", "+", "self", ".", "XMLTAG", ",", "*", "*", "attribs", ")", "return", "e" ]
Serialises the FoLiA element to XML, by returning an XML Element (in lxml.etree) for this element and all its children. For string output, consider the xmlstring() method instead.
[ "Serialises", "the", "FoLiA", "element", "to", "XML", "by", "returning", "an", "XML", "Element", "(", "in", "lxml", ".", "etree", ")", "for", "this", "element", "and", "all", "its", "children", ".", "For", "string", "output", "consider", "the", "xmlstring", "()", "method", "instead", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5402-L5418
proycon/pynlpl
pynlpl/formats/folia.py
ComplexAlignment.annotation
def annotation(self, type, set=None): """Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found""" l = self.count(type,set,True,default_ignore_annotations) if len(l) >= 1: return l[0] else: raise NoSuchAnnotation()
python
def annotation(self, type, set=None): """Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found""" l = self.count(type,set,True,default_ignore_annotations) if len(l) >= 1: return l[0] else: raise NoSuchAnnotation()
[ "def", "annotation", "(", "self", ",", "type", ",", "set", "=", "None", ")", ":", "l", "=", "self", ".", "count", "(", "type", ",", "set", ",", "True", ",", "default_ignore_annotations", ")", "if", "len", "(", "l", ")", ">=", "1", ":", "return", "l", "[", "0", "]", "else", ":", "raise", "NoSuchAnnotation", "(", ")" ]
Will return a **single** annotation (even if there are multiple). Raises a ``NoSuchAnnotation`` exception if none was found
[ "Will", "return", "a", "**", "single", "**", "annotation", "(", "even", "if", "there", "are", "multiple", ")", ".", "Raises", "a", "NoSuchAnnotation", "exception", "if", "none", "was", "found" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5514-L5520
proycon/pynlpl
pynlpl/formats/folia.py
Morpheme.findspans
def findspans(self, type,set=None): """Find span annotation of the specified type that include this word""" if issubclass(type, AbstractAnnotationLayer): layerclass = type else: layerclass = ANNOTATIONTYPE2LAYERCLASS[type.ANNOTATIONTYPE] e = self while True: if not e.parent: break e = e.parent for layer in e.select(layerclass,set,False): for e2 in layer: if isinstance(e2, AbstractSpanAnnotation): if self in e2.wrefs(): yield e2
python
def findspans(self, type,set=None): """Find span annotation of the specified type that include this word""" if issubclass(type, AbstractAnnotationLayer): layerclass = type else: layerclass = ANNOTATIONTYPE2LAYERCLASS[type.ANNOTATIONTYPE] e = self while True: if not e.parent: break e = e.parent for layer in e.select(layerclass,set,False): for e2 in layer: if isinstance(e2, AbstractSpanAnnotation): if self in e2.wrefs(): yield e2
[ "def", "findspans", "(", "self", ",", "type", ",", "set", "=", "None", ")", ":", "if", "issubclass", "(", "type", ",", "AbstractAnnotationLayer", ")", ":", "layerclass", "=", "type", "else", ":", "layerclass", "=", "ANNOTATIONTYPE2LAYERCLASS", "[", "type", ".", "ANNOTATIONTYPE", "]", "e", "=", "self", "while", "True", ":", "if", "not", "e", ".", "parent", ":", "break", "e", "=", "e", ".", "parent", "for", "layer", "in", "e", ".", "select", "(", "layerclass", ",", "set", ",", "False", ")", ":", "for", "e2", "in", "layer", ":", "if", "isinstance", "(", "e2", ",", "AbstractSpanAnnotation", ")", ":", "if", "self", "in", "e2", ".", "wrefs", "(", ")", ":", "yield", "e2" ]
Find span annotation of the specified type that include this word
[ "Find", "span", "annotation", "of", "the", "specified", "type", "that", "include", "this", "word" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5528-L5542
proycon/pynlpl
pynlpl/formats/folia.py
Sentence.correctwords
def correctwords(self, originalwords, newwords, **kwargs): """Generic correction method for words. You most likely want to use the helper functions :meth:`Sentence.splitword` , :meth:`Sentence.mergewords`, :meth:`deleteword`, :meth:`insertword` instead""" for w in originalwords: if not isinstance(w, Word): raise Exception("Original word is not a Word instance: " + str(type(w))) elif w.sentence() != self: raise Exception("Original not found as member of sentence!") for w in newwords: if not isinstance(w, Word): raise Exception("New word is not a Word instance: " + str(type(w))) if 'suggest' in kwargs and kwargs['suggest']: del kwargs['suggest'] return self.correct(suggestion=newwords,current=originalwords, **kwargs) else: return self.correct(original=originalwords, new=newwords, **kwargs)
python
def correctwords(self, originalwords, newwords, **kwargs): """Generic correction method for words. You most likely want to use the helper functions :meth:`Sentence.splitword` , :meth:`Sentence.mergewords`, :meth:`deleteword`, :meth:`insertword` instead""" for w in originalwords: if not isinstance(w, Word): raise Exception("Original word is not a Word instance: " + str(type(w))) elif w.sentence() != self: raise Exception("Original not found as member of sentence!") for w in newwords: if not isinstance(w, Word): raise Exception("New word is not a Word instance: " + str(type(w))) if 'suggest' in kwargs and kwargs['suggest']: del kwargs['suggest'] return self.correct(suggestion=newwords,current=originalwords, **kwargs) else: return self.correct(original=originalwords, new=newwords, **kwargs)
[ "def", "correctwords", "(", "self", ",", "originalwords", ",", "newwords", ",", "*", "*", "kwargs", ")", ":", "for", "w", "in", "originalwords", ":", "if", "not", "isinstance", "(", "w", ",", "Word", ")", ":", "raise", "Exception", "(", "\"Original word is not a Word instance: \"", "+", "str", "(", "type", "(", "w", ")", ")", ")", "elif", "w", ".", "sentence", "(", ")", "!=", "self", ":", "raise", "Exception", "(", "\"Original not found as member of sentence!\"", ")", "for", "w", "in", "newwords", ":", "if", "not", "isinstance", "(", "w", ",", "Word", ")", ":", "raise", "Exception", "(", "\"New word is not a Word instance: \"", "+", "str", "(", "type", "(", "w", ")", ")", ")", "if", "'suggest'", "in", "kwargs", "and", "kwargs", "[", "'suggest'", "]", ":", "del", "kwargs", "[", "'suggest'", "]", "return", "self", ".", "correct", "(", "suggestion", "=", "newwords", ",", "current", "=", "originalwords", ",", "*", "*", "kwargs", ")", "else", ":", "return", "self", ".", "correct", "(", "original", "=", "originalwords", ",", "new", "=", "newwords", ",", "*", "*", "kwargs", ")" ]
Generic correction method for words. You most likely want to use the helper functions :meth:`Sentence.splitword` , :meth:`Sentence.mergewords`, :meth:`deleteword`, :meth:`insertword` instead
[ "Generic", "correction", "method", "for", "words", ".", "You", "most", "likely", "want", "to", "use", "the", "helper", "functions", ":", "meth", ":", "Sentence", ".", "splitword", ":", "meth", ":", "Sentence", ".", "mergewords", ":", "meth", ":", "deleteword", ":", "meth", ":", "insertword", "instead" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5783-L5798
proycon/pynlpl
pynlpl/formats/folia.py
Sentence.splitword
def splitword(self, originalword, *newwords, **kwargs): """TODO: Write documentation""" if isstring(originalword): originalword = self.doc[u(originalword)] return self.correctwords([originalword], newwords, **kwargs)
python
def splitword(self, originalword, *newwords, **kwargs): """TODO: Write documentation""" if isstring(originalword): originalword = self.doc[u(originalword)] return self.correctwords([originalword], newwords, **kwargs)
[ "def", "splitword", "(", "self", ",", "originalword", ",", "*", "newwords", ",", "*", "*", "kwargs", ")", ":", "if", "isstring", "(", "originalword", ")", ":", "originalword", "=", "self", ".", "doc", "[", "u", "(", "originalword", ")", "]", "return", "self", ".", "correctwords", "(", "[", "originalword", "]", ",", "newwords", ",", "*", "*", "kwargs", ")" ]
TODO: Write documentation
[ "TODO", ":", "Write", "documentation" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5802-L5806
proycon/pynlpl
pynlpl/formats/folia.py
Sentence.mergewords
def mergewords(self, newword, *originalwords, **kwargs): """TODO: Write documentation""" return self.correctwords(originalwords, [newword], **kwargs)
python
def mergewords(self, newword, *originalwords, **kwargs): """TODO: Write documentation""" return self.correctwords(originalwords, [newword], **kwargs)
[ "def", "mergewords", "(", "self", ",", "newword", ",", "*", "originalwords", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "correctwords", "(", "originalwords", ",", "[", "newword", "]", ",", "*", "*", "kwargs", ")" ]
TODO: Write documentation
[ "TODO", ":", "Write", "documentation" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5810-L5812
proycon/pynlpl
pynlpl/formats/folia.py
Sentence.deleteword
def deleteword(self, word, **kwargs): """TODO: Write documentation""" if isstring(word): word = self.doc[u(word)] return self.correctwords([word], [], **kwargs)
python
def deleteword(self, word, **kwargs): """TODO: Write documentation""" if isstring(word): word = self.doc[u(word)] return self.correctwords([word], [], **kwargs)
[ "def", "deleteword", "(", "self", ",", "word", ",", "*", "*", "kwargs", ")", ":", "if", "isstring", "(", "word", ")", ":", "word", "=", "self", ".", "doc", "[", "u", "(", "word", ")", "]", "return", "self", ".", "correctwords", "(", "[", "word", "]", ",", "[", "]", ",", "*", "*", "kwargs", ")" ]
TODO: Write documentation
[ "TODO", ":", "Write", "documentation" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5814-L5818
proycon/pynlpl
pynlpl/formats/folia.py
Sentence.insertwordleft
def insertwordleft(self, newword, nextword, **kwargs): """Inserts a word **as a correction** before an existing word. Reverse of :meth:`Sentence.insertword`. """ if nextword: if isstring(nextword): nextword = self.doc[u(nextword)] if not nextword in self or not isinstance(nextword, Word): raise Exception("Next word not found or not instance of Word!") if isinstance(newword, list) or isinstance(newword, tuple): if not all([ isinstance(x, Word) for x in newword ]): raise Exception("New word (iterable) constains non-Word instances!") elif not isinstance(newword, Word): raise Exception("New word no instance of Word!") kwargs['insertindex'] = self.getindex(nextword) else: kwargs['insertindex'] = 0 kwargs['nooriginal'] = True if isinstance(newword, list) or isinstance(newword, tuple): return self.correctwords([], newword, **kwargs) else: return self.correctwords([], [newword], **kwargs)
python
def insertwordleft(self, newword, nextword, **kwargs): """Inserts a word **as a correction** before an existing word. Reverse of :meth:`Sentence.insertword`. """ if nextword: if isstring(nextword): nextword = self.doc[u(nextword)] if not nextword in self or not isinstance(nextword, Word): raise Exception("Next word not found or not instance of Word!") if isinstance(newword, list) or isinstance(newword, tuple): if not all([ isinstance(x, Word) for x in newword ]): raise Exception("New word (iterable) constains non-Word instances!") elif not isinstance(newword, Word): raise Exception("New word no instance of Word!") kwargs['insertindex'] = self.getindex(nextword) else: kwargs['insertindex'] = 0 kwargs['nooriginal'] = True if isinstance(newword, list) or isinstance(newword, tuple): return self.correctwords([], newword, **kwargs) else: return self.correctwords([], [newword], **kwargs)
[ "def", "insertwordleft", "(", "self", ",", "newword", ",", "nextword", ",", "*", "*", "kwargs", ")", ":", "if", "nextword", ":", "if", "isstring", "(", "nextword", ")", ":", "nextword", "=", "self", ".", "doc", "[", "u", "(", "nextword", ")", "]", "if", "not", "nextword", "in", "self", "or", "not", "isinstance", "(", "nextword", ",", "Word", ")", ":", "raise", "Exception", "(", "\"Next word not found or not instance of Word!\"", ")", "if", "isinstance", "(", "newword", ",", "list", ")", "or", "isinstance", "(", "newword", ",", "tuple", ")", ":", "if", "not", "all", "(", "[", "isinstance", "(", "x", ",", "Word", ")", "for", "x", "in", "newword", "]", ")", ":", "raise", "Exception", "(", "\"New word (iterable) constains non-Word instances!\"", ")", "elif", "not", "isinstance", "(", "newword", ",", "Word", ")", ":", "raise", "Exception", "(", "\"New word no instance of Word!\"", ")", "kwargs", "[", "'insertindex'", "]", "=", "self", ".", "getindex", "(", "nextword", ")", "else", ":", "kwargs", "[", "'insertindex'", "]", "=", "0", "kwargs", "[", "'nooriginal'", "]", "=", "True", "if", "isinstance", "(", "newword", ",", "list", ")", "or", "isinstance", "(", "newword", ",", "tuple", ")", ":", "return", "self", ".", "correctwords", "(", "[", "]", ",", "newword", ",", "*", "*", "kwargs", ")", "else", ":", "return", "self", ".", "correctwords", "(", "[", "]", ",", "[", "newword", "]", ",", "*", "*", "kwargs", ")" ]
Inserts a word **as a correction** before an existing word. Reverse of :meth:`Sentence.insertword`.
[ "Inserts", "a", "word", "**", "as", "a", "correction", "**", "before", "an", "existing", "word", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L5858-L5881
proycon/pynlpl
pynlpl/formats/folia.py
Pattern.resolve
def resolve(self,size, distribution): """Resolve a variable sized pattern to all patterns of a certain fixed size""" if not self.variablesize(): raise Exception("Can only resize patterns with * wildcards") nrofwildcards = 0 for x in self.sequence: if x == '*': nrofwildcards += 1 assert (len(distribution) == nrofwildcards) wildcardnr = 0 newsequence = [] for x in self.sequence: if x == '*': newsequence += [True] * distribution[wildcardnr] wildcardnr += 1 else: newsequence.append(x) d = { 'matchannotation':self.matchannotation, 'matchannotationset':self.matchannotationset, 'casesensitive':self.casesensitive } yield Pattern(*newsequence, **d )
python
def resolve(self,size, distribution): """Resolve a variable sized pattern to all patterns of a certain fixed size""" if not self.variablesize(): raise Exception("Can only resize patterns with * wildcards") nrofwildcards = 0 for x in self.sequence: if x == '*': nrofwildcards += 1 assert (len(distribution) == nrofwildcards) wildcardnr = 0 newsequence = [] for x in self.sequence: if x == '*': newsequence += [True] * distribution[wildcardnr] wildcardnr += 1 else: newsequence.append(x) d = { 'matchannotation':self.matchannotation, 'matchannotationset':self.matchannotationset, 'casesensitive':self.casesensitive } yield Pattern(*newsequence, **d )
[ "def", "resolve", "(", "self", ",", "size", ",", "distribution", ")", ":", "if", "not", "self", ".", "variablesize", "(", ")", ":", "raise", "Exception", "(", "\"Can only resize patterns with * wildcards\"", ")", "nrofwildcards", "=", "0", "for", "x", "in", "self", ".", "sequence", ":", "if", "x", "==", "'*'", ":", "nrofwildcards", "+=", "1", "assert", "(", "len", "(", "distribution", ")", "==", "nrofwildcards", ")", "wildcardnr", "=", "0", "newsequence", "=", "[", "]", "for", "x", "in", "self", ".", "sequence", ":", "if", "x", "==", "'*'", ":", "newsequence", "+=", "[", "True", "]", "*", "distribution", "[", "wildcardnr", "]", "wildcardnr", "+=", "1", "else", ":", "newsequence", ".", "append", "(", "x", ")", "d", "=", "{", "'matchannotation'", ":", "self", ".", "matchannotation", ",", "'matchannotationset'", ":", "self", ".", "matchannotationset", ",", "'casesensitive'", ":", "self", ".", "casesensitive", "}", "yield", "Pattern", "(", "*", "newsequence", ",", "*", "*", "d", ")" ]
Resolve a variable sized pattern to all patterns of a certain fixed size
[ "Resolve", "a", "variable", "sized", "pattern", "to", "all", "patterns", "of", "a", "certain", "fixed", "size" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L6221-L6242
proycon/pynlpl
pynlpl/formats/folia.py
Document.load
def load(self, filename): """Load a FoLiA XML file. Argument: filename (str): The file to load """ #if LXE and self.mode != Mode.XPATH: # #workaround for xml:id problem (disabled) # #f = open(filename) # #s = f.read().replace(' xml:id=', ' id=') # #f.close() # self.tree = ElementTree.parse(filename) #else: self.tree = xmltreefromfile(filename) self.parsexml(self.tree.getroot()) if self.mode != Mode.XPATH: #XML Tree is now obsolete (only needed when partially loaded for xpath queries) self.tree = None
python
def load(self, filename): """Load a FoLiA XML file. Argument: filename (str): The file to load """ #if LXE and self.mode != Mode.XPATH: # #workaround for xml:id problem (disabled) # #f = open(filename) # #s = f.read().replace(' xml:id=', ' id=') # #f.close() # self.tree = ElementTree.parse(filename) #else: self.tree = xmltreefromfile(filename) self.parsexml(self.tree.getroot()) if self.mode != Mode.XPATH: #XML Tree is now obsolete (only needed when partially loaded for xpath queries) self.tree = None
[ "def", "load", "(", "self", ",", "filename", ")", ":", "#if LXE and self.mode != Mode.XPATH:", "# #workaround for xml:id problem (disabled)", "# #f = open(filename)", "# #s = f.read().replace(' xml:id=', ' id=')", "# #f.close()", "# self.tree = ElementTree.parse(filename)", "#else:", "self", ".", "tree", "=", "xmltreefromfile", "(", "filename", ")", "self", ".", "parsexml", "(", "self", ".", "tree", ".", "getroot", "(", ")", ")", "if", "self", ".", "mode", "!=", "Mode", ".", "XPATH", ":", "#XML Tree is now obsolete (only needed when partially loaded for xpath queries)", "self", ".", "tree", "=", "None" ]
Load a FoLiA XML file. Argument: filename (str): The file to load
[ "Load", "a", "FoLiA", "XML", "file", "." ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L6495-L6512
proycon/pynlpl
pynlpl/formats/folia.py
Document.items
def items(self): """Returns a depth-first flat list of all items in the document""" l = [] for e in self.data: l += e.items() return l
python
def items(self): """Returns a depth-first flat list of all items in the document""" l = [] for e in self.data: l += e.items() return l
[ "def", "items", "(", "self", ")", ":", "l", "=", "[", "]", "for", "e", "in", "self", ".", "data", ":", "l", "+=", "e", ".", "items", "(", ")", "return", "l" ]
Returns a depth-first flat list of all items in the document
[ "Returns", "a", "depth", "-", "first", "flat", "list", "of", "all", "items", "in", "the", "document" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L6514-L6519
proycon/pynlpl
pynlpl/formats/folia.py
Document.xpath
def xpath(self, query): """Run Xpath expression and parse the resulting elements. Don't forget to use the FoLiA namesapace in your expressions, using folia: or the short form f: """ for result in self.tree.xpath(query,namespaces={'f': 'http://ilk.uvt.nl/folia','folia': 'http://ilk.uvt.nl/folia' }): yield self.parsexml(result)
python
def xpath(self, query): """Run Xpath expression and parse the resulting elements. Don't forget to use the FoLiA namesapace in your expressions, using folia: or the short form f: """ for result in self.tree.xpath(query,namespaces={'f': 'http://ilk.uvt.nl/folia','folia': 'http://ilk.uvt.nl/folia' }): yield self.parsexml(result)
[ "def", "xpath", "(", "self", ",", "query", ")", ":", "for", "result", "in", "self", ".", "tree", ".", "xpath", "(", "query", ",", "namespaces", "=", "{", "'f'", ":", "'http://ilk.uvt.nl/folia'", ",", "'folia'", ":", "'http://ilk.uvt.nl/folia'", "}", ")", ":", "yield", "self", ".", "parsexml", "(", "result", ")" ]
Run Xpath expression and parse the resulting elements. Don't forget to use the FoLiA namesapace in your expressions, using folia: or the short form f:
[ "Run", "Xpath", "expression", "and", "parse", "the", "resulting", "elements", ".", "Don", "t", "forget", "to", "use", "the", "FoLiA", "namesapace", "in", "your", "expressions", "using", "folia", ":", "or", "the", "short", "form", "f", ":" ]
train
https://github.com/proycon/pynlpl/blob/7707f69a91caaa6cde037f0d0379f1d42500a68b/pynlpl/formats/folia.py#L6521-L6524