def constructLiterals(self, word: str, parse: MorphologicalParse,
metaParse: MetamorphicParse,
fsm: FsmMorphologicalAnalyzer):
"""
Creates a list of literals with a specified word, or possible words corresponding to morphological parse.
PARAMETERS
----------
word : str
literal String
parse : MorphologicalParse
morphological parse to get possible words
metaParse : MetamorphicParse
metamorphic parse to get possible words
fsm : FsmMorphologicalAnalyzer
finite state machine morphological analyzer to be used at getting possible words
RETURNS
-------
list
A list of literal
"""
result = []
if parse.size() > 0:
if not parse.isPunctuation() and not parse.isCardinal(
) and not parse.isReal():
possibleWords = fsm.getPossibleWords(parse, metaParse)
for possibleWord in possibleWords:
result.extend(self.getLiteralsWithName(possibleWord))
else:
result.extend(self.getLiteralsWithName(word))
else:
result.extend(self.getLiteralsWithName(word))
return result
def __init__(self, parse: MorphologicalParse):
"""
Binary attribute for a given word. If the word is an auxiliary verb, the attribute will have
the value "true", otherwise "false".
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.isAuxiliary() and parse.isVerb())
def setParse(self, parseString: MorphologicalParse):
"""
Sets the morphological parse layer of the word.
PARAMETERS
----------
parseString : str
The new morphological parse of the word in string form.
"""
if parseString is not None:
self.__parse = MorphologicalParse(parseString)
else:
self.__parse = None
def getMetaMorphemeTagForParse(self, parse: MorphologicalParse,
tag: str) -> list:
"""
getMetaMorphemeTagForParse method which also takes parse as an input. It also checks the morphotactic tags.
PARAMETERS
----------
parse : MorphologicalParse
MorphologicalParse type input.
tag : str
String to get meta morphemes from.
RETURNS
-------
list
List type result which holds meta morphemes.
"""
result = []
s = tag[0]
if Word.isPunctuationSymbol(s):
tag = tag[1:]
for j in range(len(MetamorphicParse.metaMorphemes)):
if tag == self.metaMorphemes[j] and parse.containsTag(
MetamorphicParse.morphotacticTags[j]):
result.append(MetamorphicParse.morphotacticTags[j])
return result
def __init__(self, parse: MorphologicalParse):
"""
Discrete attribute for a given word. Returns the the root word
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.getWord().getName())
def __init__(self, parse: MorphologicalParse):
"""
Discrete attribute for a given word. Returns the last part of speech (main part of speech) of the word
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.getPos())
def getMetaMorphemeTagForParse(self, parse: MorphologicalParse,
tag: str) -> list:
result = []
s = tag[0]
if Word.isPunctuation(s):
tag = tag[1:]
for j in range(len(MetamorphicParse.metaMorphemes)):
if tag == self.metaMorphemes[j] and parse.containsTag(
MetamorphicParse.morphotacticTags[j]):
result.append(MetamorphicParse.morphotacticTags[j])
return result
def __init__(self, parse: MorphologicalParse):
"""
Binary attribute for a given word. If the word represents a date (if the morphological parse contains
tag PROPERNOUN), the attribute will have the value "true", otherwise "false".
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.isProperNoun())
def __init__(self, parse: MorphologicalParse):
"""
Binary attribute for a given word. If the word is represents a real number (if the morphological parse contains
tag REAL), the attribute will have the value "true", otherwise "false".
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.isReal())
def __init__(self, parse: MorphologicalParse):
"""
Discrete attribute for a given word. If the last inflectional group of the word contains case information, the
attribute will have that case value. Otherwise the attribute will have the value null.
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.lastIGContainsCase())
def __init__(self, parse: MorphologicalParse):
"""
Binary attribute for a given word. If the last inflectional group of the word contains POSSESSIVE tag,
the attribute will be "true", otherwise "false".
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
"""
super().__init__(parse.lastIGContainsPossessive())
def setLayerValue(self, layerValue: str):
self.items = []
if isinstance(layerValue, str):
self.layerValue = layerValue
if layerValue is not None:
splitWords = self.layerValue.split(" ")
for word in splitWords:
self.items.append(MorphologicalParse(word))
elif isinstance(layerValue, MorphologicalParse):
parse = layerValue
self.layerValue = parse.getTransitionList()
self.items.append(parse)
def __init__(self, parse: MorphologicalParse, tag: MorphologicalTag):
"""
Binary attribute for a given word. If the last inflectional group of the word contains tag,
the attribute will be "true", otherwise "false".
PARAMETERS
----------
parse : MorphologicalParse
Morphological parse of the word.
tag : MorphologicalTag
Tag that is checked in the last inflectional group.
"""
super().__init__(parse.lastIGContainsTag(tag))
def __init__(self, fileName=None):
"""
Constructor which creates a list of sentences and a CounterHashMap of wordList.
"""
super().__init__()
if fileName is not None:
inputFile = open(fileName, "r", encoding="utf8")
lines = inputFile.readlines()
newSentence = Sentence()
for line in lines:
word = line[:line.index("\t")]
parse = line[line.index("\t") + 1:]
if len(word) > 0 and len(parse) > 0:
newWord = DisambiguatedWord(word, MorphologicalParse(parse.strip()))
if word == "<S>":
newSentence = Sentence()
elif word == "</S>":
self.addSentence(newSentence)
elif word == "<DOC>" or word == "</DOC>" or word == "<TITLE>" or word == "</TITLE>":
pass
else:
newSentence.addWord(newWord)
inputFile.close()
def setMorphologicalAnalysis(self, parse: MorphologicalParse):
self.layers[
ViewLayerType.INFLECTIONAL_GROUP] = MorphologicalAnalysisLayer(
parse.__str__())
self.layers[ViewLayerType.PART_OF_SPEECH] = MorphologicalAnalysisLayer(
parse.__str__())
def setUp(self) -> None:
self.parse1 = MorphologicalParse("bayan+NOUN+A3SG+PNON+NOM")
self.parse2 = MorphologicalParse("yaşa+VERB+POS^DB+ADJ+PRESPART")
self.parse3 = MorphologicalParse("serbest+ADJ")
self.parse4 = MorphologicalParse(
"et+VERB^DB+VERB+PASS^DB+VERB+ABLE+NEG+AOR+A3SG")
self.parse5 = MorphologicalParse(
"sür+VERB^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+NOUN+INF2+A3SG+P3SG+NOM"
)
self.parse6 = MorphologicalParse(
"değiş+VERB^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+VERB+ABLE+AOR^DB+ADJ+ZERO"
)
self.parse7 = MorphologicalParse(
"iyi+ADJ^DB+VERB+BECOME^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+VERB+ABLE^DB+NOUN+INF2+A3PL+P3PL+ABL"
)
self.parse8 = MorphologicalParse("değil+ADJ^DB+VERB+ZERO+PAST+A3SG")
self.parse9 = MorphologicalParse("hazır+ADJ^DB+VERB+ZERO+PAST+A3SG")
class MorphologicalParseTest(unittest.TestCase):
parse1: MorphologicalParse
parse2: MorphologicalParse
parse3: MorphologicalParse
parse4: MorphologicalParse
parse5: MorphologicalParse
parse6: MorphologicalParse
parse7: MorphologicalParse
parse8: MorphologicalParse
parse9: MorphologicalParse
def setUp(self) -> None:
self.parse1 = MorphologicalParse("bayan+NOUN+A3SG+PNON+NOM")
self.parse2 = MorphologicalParse("yaşa+VERB+POS^DB+ADJ+PRESPART")
self.parse3 = MorphologicalParse("serbest+ADJ")
self.parse4 = MorphologicalParse(
"et+VERB^DB+VERB+PASS^DB+VERB+ABLE+NEG+AOR+A3SG")
self.parse5 = MorphologicalParse(
"sür+VERB^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+NOUN+INF2+A3SG+P3SG+NOM"
)
self.parse6 = MorphologicalParse(
"değiş+VERB^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+VERB+ABLE+AOR^DB+ADJ+ZERO"
)
self.parse7 = MorphologicalParse(
"iyi+ADJ^DB+VERB+BECOME^DB+VERB+CAUS^DB+VERB+PASS+POS^DB+VERB+ABLE^DB+NOUN+INF2+A3PL+P3PL+ABL"
)
self.parse8 = MorphologicalParse("değil+ADJ^DB+VERB+ZERO+PAST+A3SG")
self.parse9 = MorphologicalParse("hazır+ADJ^DB+VERB+ZERO+PAST+A3SG")
def test_GetTransitionList(self):
self.assertEqual("NOUN+A3SG+PNON+NOM", self.parse1.getTransitionList())
self.assertEqual("VERB+POS+ADJ+PRESPART",
self.parse2.getTransitionList())
self.assertEqual("ADJ", self.parse3.getTransitionList())
self.assertEqual("VERB+VERB+PASS+VERB+ABLE+NEG+AOR+A3SG",
self.parse4.getTransitionList())
self.assertEqual(
"VERB+VERB+CAUS+VERB+PASS+POS+NOUN+INF2+A3SG+P3SG+NOM",
self.parse5.getTransitionList())
self.assertEqual("VERB+VERB+CAUS+VERB+PASS+POS+VERB+ABLE+AOR+ADJ+ZERO",
self.parse6.getTransitionList())
self.assertEqual(
"ADJ+VERB+BECOME+VERB+CAUS+VERB+PASS+POS+VERB+ABLE+NOUN+INF2+A3PL+P3PL+ABL",
self.parse7.getTransitionList())
self.assertEqual("ADJ+VERB+ZERO+PAST+A3SG",
self.parse8.getTransitionList())
def test_GetTag(self):
self.assertEqual("A3SG", self.parse1.getTag(2))
self.assertEqual("PRESPART", self.parse2.getTag(4))
self.assertEqual("serbest", self.parse3.getTag(0))
self.assertEqual("AOR", self.parse4.getTag(7))
self.assertEqual("P3SG", self.parse5.getTag(10))
self.assertEqual("ABLE", self.parse6.getTag(8))
self.assertEqual("ABL", self.parse7.getTag(15))
def test_GetTagSize(self):
self.assertEqual(5, self.parse1.tagSize())
self.assertEqual(5, self.parse2.tagSize())
self.assertEqual(2, self.parse3.tagSize())
self.assertEqual(9, self.parse4.tagSize())
self.assertEqual(12, self.parse5.tagSize())
self.assertEqual(12, self.parse6.tagSize())
self.assertEqual(16, self.parse7.tagSize())
self.assertEqual(6, self.parse8.tagSize())
def test_Size(self):
self.assertEqual(1, self.parse1.size())
self.assertEqual(2, self.parse2.size())
self.assertEqual(1, self.parse3.size())
self.assertEqual(3, self.parse4.size())
self.assertEqual(4, self.parse5.size())
self.assertEqual(5, self.parse6.size())
self.assertEqual(6, self.parse7.size())
self.assertEqual(2, self.parse8.size())
def test_GetRootPos(self):
self.assertEqual("NOUN", self.parse1.getRootPos())
self.assertEqual("VERB", self.parse2.getRootPos())
self.assertEqual("ADJ", self.parse3.getRootPos())
self.assertEqual("VERB", self.parse4.getRootPos())
self.assertEqual("VERB", self.parse5.getRootPos())
self.assertEqual("VERB", self.parse6.getRootPos())
self.assertEqual("ADJ", self.parse7.getRootPos())
self.assertEqual("ADJ", self.parse8.getRootPos())
def test_GetPos(self):
self.assertEqual("NOUN", self.parse1.getPos())
self.assertEqual("ADJ", self.parse2.getPos())
self.assertEqual("ADJ", self.parse3.getPos())
self.assertEqual("VERB", self.parse4.getPos())
self.assertEqual("NOUN", self.parse5.getPos())
self.assertEqual("ADJ", self.parse6.getPos())
self.assertEqual("NOUN", self.parse7.getPos())
self.assertEqual("VERB", self.parse8.getPos())
def test_GetWordWithPos(self):
self.assertEqual("bayan+NOUN", self.parse1.getWordWithPos().getName())
self.assertEqual("yaşa+VERB", self.parse2.getWordWithPos().getName())
self.assertEqual("serbest+ADJ", self.parse3.getWordWithPos().getName())
self.assertEqual("et+VERB", self.parse4.getWordWithPos().getName())
self.assertEqual("sür+VERB", self.parse5.getWordWithPos().getName())
self.assertEqual("değiş+VERB", self.parse6.getWordWithPos().getName())
self.assertEqual("iyi+ADJ", self.parse7.getWordWithPos().getName())
self.assertEqual("değil+ADJ", self.parse8.getWordWithPos().getName())
def test_LastIGContainsCase(self):
self.assertEqual("NOM", self.parse1.lastIGContainsCase())
self.assertEqual("NULL", self.parse2.lastIGContainsCase())
self.assertEqual("NULL", self.parse3.lastIGContainsCase())
self.assertEqual("NULL", self.parse4.lastIGContainsCase())
self.assertEqual("NOM", self.parse5.lastIGContainsCase())
self.assertEqual("NULL", self.parse6.lastIGContainsCase())
self.assertEqual("ABL", self.parse7.lastIGContainsCase())
def test_LastIGContainsPossessive(self):
self.assertFalse(self.parse1.lastIGContainsPossessive())
self.assertFalse(self.parse2.lastIGContainsPossessive())
self.assertFalse(self.parse3.lastIGContainsPossessive())
self.assertFalse(self.parse4.lastIGContainsPossessive())
self.assertTrue(self.parse5.lastIGContainsPossessive())
self.assertFalse(self.parse6.lastIGContainsPossessive())
self.assertTrue(self.parse7.lastIGContainsPossessive())
def test_IsPlural(self):
self.assertFalse(self.parse1.isPlural())
self.assertFalse(self.parse2.isPlural())
self.assertFalse(self.parse3.isPlural())
self.assertFalse(self.parse4.isPlural())
self.assertFalse(self.parse5.isPlural())
self.assertFalse(self.parse6.isPlural())
self.assertTrue(self.parse7.isPlural())
def test_IsAuxiliary(self):
self.assertFalse(self.parse1.isAuxiliary())
self.assertFalse(self.parse2.isAuxiliary())
self.assertFalse(self.parse3.isAuxiliary())
self.assertTrue(self.parse4.isAuxiliary())
self.assertFalse(self.parse5.isAuxiliary())
self.assertFalse(self.parse6.isAuxiliary())
self.assertFalse(self.parse7.isAuxiliary())
def test_IsNoun(self):
self.assertTrue(self.parse1.isNoun())
self.assertTrue(self.parse5.isNoun())
self.assertTrue(self.parse7.isNoun())
def test_IsAdjective(self):
self.assertTrue(self.parse2.isAdjective())
self.assertTrue(self.parse3.isAdjective())
self.assertTrue(self.parse6.isAdjective())
def test_IsVerb(self):
self.assertTrue(self.parse4.isVerb())
self.assertTrue(self.parse8.isVerb())
def test_IsRootVerb(self):
self.assertTrue(self.parse2.isRootVerb())
self.assertTrue(self.parse4.isRootVerb())
self.assertTrue(self.parse5.isRootVerb())
self.assertTrue(self.parse6.isRootVerb())
def test_GetTreePos(self):
self.assertEqual("NP", self.parse1.getTreePos())
self.assertEqual("ADJP", self.parse2.getTreePos())
self.assertEqual("ADJP", self.parse3.getTreePos())
self.assertEqual("VP", self.parse4.getTreePos())
self.assertEqual("NP", self.parse5.getTreePos())
self.assertEqual("ADJP", self.parse6.getTreePos())
self.assertEqual("NP", self.parse7.getTreePos())
self.assertEqual("NEG", self.parse8.getTreePos())
self.assertEqual("NOMP", self.parse9.getTreePos())
def constructSynSets(self, word: str, parse: MorphologicalParse,
metaParse: MetamorphicParse,
fsm: FsmMorphologicalAnalyzer) -> list:
"""
Creates a list of SynSets with a specified word, or possible words corresponding to morphological parse.
PARAMETERS
----------
word : str
literal String to get SynSets with
parse : MorphologicalParse
morphological parse to get SynSets with proper literals
metaParse : MetamorphicParse
metamorphic parse to get possible words
fsm : FsmMorphologicalAnalyzer
finite state machine morphological analyzer to be used at getting possible words
RETURNS
-------
list
A list of SynSets
"""
result = []
if parse.size() > 0:
if parse.isProperNoun():
result.append(self.getSynSetWithLiteral("(özel isim)", 1))
if parse.isTime():
result.append(self.getSynSetWithLiteral("(zaman)", 1))
if parse.isDate():
result.append(self.getSynSetWithLiteral("(tarih)", 1))
if parse.isHashTag():
result.append(self.getSynSetWithLiteral("(hashtag)", 1))
if parse.isEmail():
result.append(self.getSynSetWithLiteral("(email)", 1))
if parse.isOrdinal():
result.append(
self.getSynSetWithLiteral("(sayı sıra sıfatı)", 1))
if parse.isPercent():
result.append(self.getSynSetWithLiteral("(yüzde)", 1))
if parse.isFraction():
result.append(self.getSynSetWithLiteral("(kesir sayı)", 1))
if parse.isRange():
result.append(self.getSynSetWithLiteral("(sayı aralığı)", 1))
if parse.isReal():
result.append(self.getSynSetWithLiteral("(reel sayı)", 1))
if not parse.isPunctuation() and not parse.isCardinal(
) and not parse.isReal():
possibleWords = fsm.getPossibleWords(parse, metaParse)
for possibleWord in possibleWords:
synSets = self.getSynSetsWithLiteral(possibleWord)
if len(synSets) > 0:
for synSet in synSets:
if synSet.getPos() is not None and (
parse.getPos() == "NOUN" or parse.getPos()
== "ADVERB" or parse.getPos() == "VERB"
or parse.getPos() == "ADJ"
or parse.getPos() == "CONJ"):
if synSet.getPos() == Pos.NOUN:
if parse.getPos(
) == "NOUN" or parse.getRootPos(
) == "NOUN":
result.append(synSet)
elif synSet.getPos() == Pos.ADVERB:
if parse.getPos(
) == "ADVERB" or parse.getRootPos(
) == "ADVERB":
result.append(synSet)
elif synSet.getPos() == Pos.VERB:
if parse.getPos(
) == "VERB" or parse.getRootPos(
) == "VERB":
result.append(synSet)
elif synSet.getPos() == Pos.ADJECTIVE:
if parse.getPos(
) == "ADJ" or parse.getRootPos() == "ADJ":
result.append(synSet)
elif synSet.getPos() == Pos.CONJUNCTION:
if parse.getPos(
) == "CONJ" or parse.getRootPos(
) == "CONJ":
result.append(synSet)
else:
result.append(synSet)
else:
result.append(synSet)
if len(result) == 0:
for possibleWord in possibleWords:
synSets = self.getSynSetsWithLiteral(possibleWord)
result.extend(synSets)
else:
result.extend(self.getSynSetsWithLiteral(word))
if parse.isCardinal() and len(result) == 0:
result.append(self.getSynSetWithLiteral("(tam sayı)", 1))
else:
result.extend(self.getSynSetsWithLiteral(word))
return result
def __init__(self, word: str, layerType=None):
"""
Constructor for the AnnotatedWord class. Gets the word with its annotation layers as input and sets the
corresponding layers.
PARAMETERS
----------
word : str
Input word with annotation layers
"""
self.__parse = None
self.__metamorphicParse = None
self.__semantic = None
self.__namedEntityType = None
self.__argument = None
self.__frameElement = None
self.__shallowParse = None
self.__universalDependency = None
if layerType is None:
splitLayers = re.compile("[{}]").split(word)
for layer in splitLayers:
if len(layer) == 0:
continue
if "=" not in layer:
self.name = layer
continue
layerType = layer[:layer.index("=")]
layerValue = layer[layer.index("=") + 1:]
if layerType == "turkish":
self.name = layerValue
elif layerType == "morphologicalAnalysis":
self.__parse = MorphologicalParse(layerValue)
elif layerType == "metaMorphemes":
self.__metamorphicParse = MetamorphicParse(layerValue)
elif layerType == "namedEntity":
self.__namedEntityType = NamedEntityType.getNamedEntityType(
layerValue)
elif layerType == "propbank":
self.__argument = Argument(layerValue)
elif layerType == "framenet":
self.__frameElement = FrameElement(layerValue)
elif layerType == "shallowParse":
self.__shallowParse = layerValue
elif layerType == "semantics":
self.__semantic = layerValue
elif layerType == "universalDependency":
values = layerValue.split("$")
self.__universalDependency = UniversalDependencyRelation(
int(values[0]), values[1])
elif isinstance(layerType, NamedEntityType):
super().__init__(word)
self.__namedEntityType = layerType
self.__argument = Argument("NONE")
elif isinstance(layerType, MorphologicalParse):
super().__init__(word)
self.__parse = layerType
self.__namedEntityType = NamedEntityType.NONE
self.__argument = Argument("NONE")
elif isinstance(layerType, FsmParse):
super().__init__(word)
self.__parse = layerType
self.__namedEntityType = NamedEntityType.NONE
self.setMetamorphicParse(layerType.withList())
self.__argument = Argument("NONE")
class AnnotatedWord(Word):
__parse: MorphologicalParse
__metamorphicParse: MetamorphicParse
__semantic: str
__namedEntityType: NamedEntityType
__argument: Argument
__frameElement: FrameElement
__shallowParse: str
__universalDependency: UniversalDependencyRelation
def __init__(self, word: str, layerType=None):
"""
Constructor for the AnnotatedWord class. Gets the word with its annotation layers as input and sets the
corresponding layers.
PARAMETERS
----------
word : str
Input word with annotation layers
"""
self.__parse = None
self.__metamorphicParse = None
self.__semantic = None
self.__namedEntityType = None
self.__argument = None
self.__frameElement = None
self.__shallowParse = None
self.__universalDependency = None
if layerType is None:
splitLayers = re.compile("[{}]").split(word)
for layer in splitLayers:
if len(layer) == 0:
continue
if "=" not in layer:
self.name = layer
continue
layerType = layer[:layer.index("=")]
layerValue = layer[layer.index("=") + 1:]
if layerType == "turkish":
self.name = layerValue
elif layerType == "morphologicalAnalysis":
self.__parse = MorphologicalParse(layerValue)
elif layerType == "metaMorphemes":
self.__metamorphicParse = MetamorphicParse(layerValue)
elif layerType == "namedEntity":
self.__namedEntityType = NamedEntityType.getNamedEntityType(
layerValue)
elif layerType == "propbank":
self.__argument = Argument(layerValue)
elif layerType == "framenet":
self.__frameElement = FrameElement(layerValue)
elif layerType == "shallowParse":
self.__shallowParse = layerValue
elif layerType == "semantics":
self.__semantic = layerValue
elif layerType == "universalDependency":
values = layerValue.split("$")
self.__universalDependency = UniversalDependencyRelation(
int(values[0]), values[1])
elif isinstance(layerType, NamedEntityType):
super().__init__(word)
self.__namedEntityType = layerType
self.__argument = Argument("NONE")
elif isinstance(layerType, MorphologicalParse):
super().__init__(word)
self.__parse = layerType
self.__namedEntityType = NamedEntityType.NONE
self.__argument = Argument("NONE")
elif isinstance(layerType, FsmParse):
super().__init__(word)
self.__parse = layerType
self.__namedEntityType = NamedEntityType.NONE
self.setMetamorphicParse(layerType.withList())
self.__argument = Argument("NONE")
def __str__(self) -> str:
"""
Converts an AnnotatedWord to string. For each annotation layer, the method puts a left brace, layer name,
equal sign and layer value finishing with right brace.
RETURNS
-------
str
String form of the AnnotatedWord.
"""
result = "{turkish=" + self.name + "}"
if self.__parse is not None:
result = result + "{morphologicalAnalysis=" + self.__parse.__str__(
) + "}"
if self.__metamorphicParse is not None:
result = result + "{metaMorphemes=" + self.__metamorphicParse.__str__(
) + "}"
if self.__semantic is not None:
result = result + "{semantics=" + self.__semantic + "}"
if self.__namedEntityType is not None:
result = result + "{namedEntity=" + NamedEntityType.getNamedEntityString(
self.__namedEntityType) + "}"
if self.__argument is not None:
result = result + "{propbank=" + self.__argument.__str__() + "}"
if self.__frameElement is not None:
result = result + "{framenet=" + self.__frameElement.__str__(
) + "}"
if self.__shallowParse is not None:
result = result + "{shallowParse=" + self.__shallowParse + "}"
if self.__universalDependency is not None:
result = result + "{universalDependency=" + self.__universalDependency.to().__str__() + "$" + \
self.__universalDependency.__str__() + "}"
return result
def getLayerInfo(self, viewLayerType: ViewLayerType) -> str:
"""
Returns the value of a given layer.
PARAMETERS
----------
viewLayerType : ViewLayerType
Layer for which the value questioned.
RETURNS
-------
str
The value of the given layer.
"""
if viewLayerType == ViewLayerType.INFLECTIONAL_GROUP:
if self.__parse is not None:
return self.__parse.__str__()
elif viewLayerType == ViewLayerType.META_MORPHEME:
if self.__metamorphicParse is not None:
return self.__metamorphicParse.__str__()
elif viewLayerType == ViewLayerType.SEMANTICS:
return self.__semantic
elif viewLayerType == ViewLayerType.NER:
if self.__namedEntityType is not None:
return self.__namedEntityType.__str__()
elif viewLayerType == ViewLayerType.SHALLOW_PARSE:
return self.__shallowParse
elif viewLayerType == ViewLayerType.TURKISH_WORD:
return self.name
elif viewLayerType == ViewLayerType.PROPBANK:
if self.__argument is not None:
return self.__argument.__str__()
elif viewLayerType == ViewLayerType.FRAMENET:
if self.__frameElement is not None:
return self.__frameElement.__str__()
elif viewLayerType == ViewLayerType.DEPENDENCY:
if self.__universalDependency is not None:
return self.__universalDependency.to().__str__(
) + "$" + self.__universalDependency.__str__()
else:
return None
def getParse(self) -> MorphologicalParse:
"""
Returns the morphological parse layer of the word.
RETURNS
-------
MorphologicalParse
The morphological parse of the word.
"""
return self.__parse
def setParse(self, parseString: MorphologicalParse):
"""
Sets the morphological parse layer of the word.
PARAMETERS
----------
parseString : str
The new morphological parse of the word in string form.
"""
if parseString is not None:
self.__parse = MorphologicalParse(parseString)
else:
self.__parse = None
def getMetamorphicParse(self) -> MetamorphicParse:
"""
Returns the metamorphic parse layer of the word.
RETURNS
-------
MetamorphicParse
The metamorphic parse of the word.
"""
return self.__metamorphicParse
def setMetamorphicParse(self, parseString: str):
"""
Sets the metamorphic parse layer of the word.
PARAMETERS
----------
parseString : str
The new metamorphic parse of the word in string form.
"""
self.__metamorphicParse = MetamorphicParse(parseString)
def getSemantic(self) -> str:
"""
Returns the semantic layer of the word.
RETURNS
-------
str
Sense id of the word.
"""
return self.__semantic
def setSemantic(self, semantic: str):
"""
Sets the semantic layer of the word.
PARAMETERS
----------
semantic : str
New sense id of the word.
"""
self.__semantic = semantic
def getNamedEntityType(self) -> NamedEntityType:
"""
Returns the named entity layer of the word.
RETURNS
-------
NamedEntityType
Named entity tag of the word.
"""
return self.__namedEntityType
def setNamedEntityType(self, namedEntity: str):
"""
Sets the named entity layer of the word.
PARAMETERS
----------
namedEntity : str
New named entity tag of the word.
"""
if namedEntity is not None:
self.__namedEntityType = NamedEntityType.getNamedEntityType(
namedEntity)
else:
self.__namedEntityType = None
def getArgument(self) -> Argument:
"""
Returns the semantic role layer of the word.
RETURNS
-------
Argument
Semantic role tag of the word.
"""
return self.__argument
def setArgument(self, argument: str):
"""
Sets the semantic role layer of the word.
PARAMETERS
----------
argument : Argument
New semantic role tag of the word.
"""
if self.__argument is not None:
self.__argument = Argument(argument)
else:
self.__argument = None
def getFrameElement(self) -> FrameElement:
"""
Returns the framenet layer of the word.
RETURNS
-------
FrameElement
Framenet tag of the word.
"""
return self.__frameElement
def setFrameElement(self, frameElement: str):
"""
Sets the framenet layer of the word.
PARAMETERS
----------
frameElement : str
New framenet tag of the word.
"""
if self.__frameElement is not None:
self.__frameElement = Argument(frameElement)
else:
self.__frameElement = None
def getShallowParse(self) -> str:
"""
Returns the shallow parse layer of the word.
RETURNS
-------
str
Shallow parse tag of the word.
"""
return self.__shallowParse
def setShallowParse(self, parse: str):
"""
Sets the shallow parse layer of the word.
PARAMETERS
----------
parse : str
New shallow parse tag of the word.
"""
self.__shallowParse = parse
def getUniversalDependency(self) -> UniversalDependencyRelation:
"""
Returns the universal dependency layer of the word.
RETURNS
-------
UniversalDependencyRelation
Universal dependency relation of the word.
"""
return self.__universalDependency
def setUniversalDependency(self, to: int, dependencyType: str):
"""
Sets the universal dependency layer of the word.
PARAMETERS
----------
to : int
to Word related to.
dependencyType : str
type of dependency the word is related to.
"""
self.__universalDependency = UniversalDependencyRelation(
to, dependencyType)
def getUniversalDependencyFormat(self, sentenceLength: int) -> str:
if self.__parse is not None:
result = self.name + "\t" + self.__parse.getWord().getName() + "\t" + \
self.__parse.getUniversalDependencyPos() + "\t_\t"
features = self.__parse.getUniversalDependencyFeatures()
if len(features) == 0:
result = result + "_"
else:
first = True
for feature in features:
if first:
first = False
else:
result += "|"
result += feature
result += "\t"
if self.__universalDependency is not None and self.__universalDependency.to(
) <= sentenceLength:
result += self.__universalDependency.to().__str__() + "\t" + \
self.__universalDependency.__str__().lower() + "\t"
else:
result += "_\t_\t"
result += "_\t_"
return result
else:
return self.name + "\t" + self.name + "\t_\t_\t_\t_\t_\t_\t_"
def getFormattedString(self, wordFormat: WordFormat):
if wordFormat == WordFormat.SURFACE:
return self.name
return self.name
def checkGazetteer(self, gazetteer: Gazetteer):
wordLowercase = self.name.lower()
if gazetteer.contains(wordLowercase) and self.__parse.containsTag(
MorphologicalTag.PROPERNOUN):
self.setNamedEntityType(gazetteer.getName())
if "'" in wordLowercase and gazetteer.contains(wordLowercase[:wordLowercase.index("'")]) and \
self.__parse.containsTag(MorphologicalTag.PROPERNOUN):
self.setNamedEntityType(gazetteer.getName())
