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 |