nlptoolkit-amr 1.0.0__tar.gz

nlptoolkit_amr-1.0.0/Construction/AmrConstructionAlgorithm.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from abc import abstractmethod
+from typing import List
+
+from AnnotatedSentence.AnnotatedSentence import AnnotatedSentence
+
+class AmrConstructionAlgorithm(object):
+
+    @abstractmethod
+    def constructExcelAmr(self, sentence: AnnotatedSentence) -> list[str]:
+        pass
+
+    def toString(self, sentence: AnnotatedSentence):
+        result = ""
+        for item in self.constructExcelAmr(sentence):
+            result += item + "\n"
+        return result
+
+    def saveAmr(self, items: List[str], fileName: str):
+        start_x = 750
+        start_y = 100
+        last_parent = [""] * 50
+        last_x = [0] * 50
+        child_count = [0] * 50
+        words = set()
+        out_file = open(fileName, "w", encoding="utf8")
+        out_file.write("<Amr>\n")
+        line = items[0]
+        out_file.write("<Word name=\"" + line + "\" positionX=\"" + str(start_x) + "\" positionY=\"" + str(start_y) + "\"/>\n")
+        words.add(line)
+        last_parent[0] = line
+        child_count[0] = 0
+        last_x[0] = start_x
+        for j in range (1, len(items)):
+            line = items[j]
+            tab_count = 0
+            i = 0
+            while line[i] == '\t':
+                tab_count = tab_count + 1
+                i = i + 1
+            line = line[tab_count:]
+            if ":" in line:
+                last_parent[tab_count] = line[0: line.index(":")]
+            else:
+                last_parent[tab_count] = line
+            child_count[tab_count] = 0
+            last_x[tab_count] = last_x[tab_count - 1] + (child_count[tab_count - 1] - 1) * 100
+            if ":" in line:
+                candidate = line[0: line.rindex(":")]
+                if not candidate in words:
+                    out_file.write("<Word name=\"" + candidate + "\" positionX=\"" + str(last_x[tab_count]) + "\" positionY=\"" + str(start_y + 100 * tab_count) + "\"/>\n")
+                    words.add(candidate)
+                out_file.write("<Connection from=\"" + last_parent[tab_count - 1] + "\" to=\"" + candidate + "\" with=\"" + line[0: line.rindex(":") + 1] + "\"/>\n")
+            else:
+                if not line in words:
+                    out_file.write("<Word name=\"" + line + "\" positionX=\"" + str(last_x[tab_count]) + "\" positionY=\"" + str(start_y + 100 * tab_count) + "\"/>")
+                    words.add(line)
+                out_file.write("<Connection from=\"" + last_parent[tab_count - 1] + "\" to=\"" + line + "\"/>\n")
+            child_count[tab_count - 1] = child_count[tab_count - 1] + 1
+        out_file.write("</Amr>\n")
+        out_file.close()

nlptoolkit_amr-1.0.0/Construction/RuleBasedConstructionAlgorithm.py

@@ -0,0 +1,355 @@
+from typing import List
+
+from AnnotatedSentence.AnnotatedSentence import AnnotatedSentence
+from AnnotatedSentence.AnnotatedWord import AnnotatedWord
+from MorphologicalAnalysis import MorphologicalTag
+from WordNet import SemanticRelation
+from WordNet.SynSet import SynSet
+from WordNet.WordNet import WordNet
+from WordNet.SemanticRelation import SemanticRelation
+
+from AmrConstructionAlgorithm import AmrConstructionAlgorithm
+from MorphologicalAnalysis.MorphologicalTag import MorphologicalTag
+
+class RuleBasedConstructionAlgorithm(AmrConstructionAlgorithm):
+
+    __word_net: WordNet
+    __sentence: AnnotatedSentence
+
+    def __init__(self, word_net: WordNet) -> None:
+        self.__word_net = word_net
+
+    def __with_tabs(self, tabCount: int, string: str) -> str:
+        result = ""
+        for i in range(tabCount):
+            result += "\t"
+        return result + string
+
+    def __only_word(self, word: AnnotatedWord, i: int) -> str:
+        return str(i + 1) + "/" + word.getParse().getWord().getName()
+
+    def __contains_arg0(self, semantic: str) -> bool:
+        for i in range(self.__sentence.wordCount()):
+            word = self.__sentence.getWord(i)
+            if isinstance(word, AnnotatedWord) and word.getArgumentList() and word.getArgumentList().containsArgument("ARG0", semantic):
+                return True
+        return False
+
+    def __extra_args(self, output: List[str], word: AnnotatedWord, tabCount: int):
+        if word.getParse().getRootPos() == "VERB" and word.getParse().containsTag(MorphologicalTag.A1SG) and "ben " not in self.__sentence.toStems():
+            output.append(self.__with_tabs(tabCount + 1, "ben:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().getPos() == "NOUN" and word.getParse().containsTag(MorphologicalTag.P1SG):
+            output.append(self.__with_tabs(tabCount + 1, "ben:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().containsTag(MorphologicalTag.A1PL) and "biz " not in self.__sentence.toStems():
+            output.append(self.__with_tabs(tabCount + 1, "biz:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().getPos() == "NOUN" and word.getParse().containsTag(MorphologicalTag.P1PL):
+            output.append(self.__with_tabs(tabCount + 1, "biz:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().containsTag(MorphologicalTag.A2SG) and "sen " not in self.__sentence.toStems():
+            output.append(self.__with_tabs(tabCount + 1, "sen:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().getPos() == "NOUN" and word.getParse().containsTag(MorphologicalTag.P2SG):
+            output.append(self.__with_tabs(tabCount + 1, "sen:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().containsTag(MorphologicalTag.A2PL) and "siz " not in self.__sentence.toStems():
+            output.append(self.__with_tabs(tabCount + 1, "siz:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().getPos() == "NOUN" and word.getParse().containsTag(MorphologicalTag.P2PL):
+            output.append(self.__with_tabs(tabCount + 1, "siz:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().containsTag(MorphologicalTag.A3SG) and "o " not in self.__sentence.toStems():
+            if not self.__contains_arg0(word.getSemantic()):
+                if not (word.getParse().getPos() == "NOUN" and (word.getParse().containsTag(MorphologicalTag.P1SG) or word.getParse().containsTag(MorphologicalTag.P1PL) or word.getParse().containsTag(MorphologicalTag.P2SG) or word.getParse().containsTag(MorphologicalTag.P2PL))):
+                    output.append(self.__with_tabs(tabCount + 1, "o:ARG0"))
+        if word.getParse().getRootPos() == "VERB" and word.getParse().containsTag(MorphologicalTag.A3PL) and "onlar " not in self.__sentence.toStems():
+            if not self.__contains_arg0(word.getSemantic()):
+                if not (word.getParse().getPos() == "NOUN" and (word.getParse().containsTag(MorphologicalTag.P1SG) or word.getParse().containsTag(MorphologicalTag.P1PL) or word.getParse().containsTag(MorphologicalTag.P2SG) or word.getParse().containsTag(MorphologicalTag.P2PL))):
+                    output.append(self.__with_tabs(tabCount + 1, "onlar:ARG0"))
+
+    def __contains_mode(self, index: int) -> bool:
+        for i in range(self.__sentence.wordCount()):
+            word = self.__sentence.getWord(i)
+            if isinstance(word, AnnotatedWord) and word.getUniversalDependency() is not None and word.getUniversalDependency().to() == index + 1:
+                if word.getUniversalDependency().__str__() == "AMOD" or word.getUniversalDependency().__str__() == "NMOD":
+                    return True
+        return False
+
+    def __extra_possessive(self, output: List[str], word: AnnotatedWord, wordIndex: int, tabCount: int):
+        if word.getParse().containsTag(MorphologicalTag.P1SG):
+            if word.getParse().getRootPos() != "VERB" or word.getParse().getRootPos() != "NOUN":
+                output.append(self.__with_tabs(tabCount + 1, "ben:poss"))
+        if word.getParse().containsTag(MorphologicalTag.P1PL):
+            if word.getParse().getRootPos() != "VERB" or word.getParse().getRootPos() != "NOUN":
+                output.append(self.__with_tabs(tabCount + 1, "biz:poss"))
+        if word.getParse().containsTag(MorphologicalTag.P2SG):
+            if word.getParse().getRootPos() != "VERB" or word.getParse().getRootPos() != "NOUN":
+                output.append(self.__with_tabs(tabCount + 1, "sen:poss"))
+        if word.getParse().containsTag(MorphologicalTag.P2PL):
+            if word.getParse().getRootPos() != "VERB" or word.getParse().getRootPos() != "NOUN":
+                output.append(self.__with_tabs(tabCount + 1, "siz:poss"))
+        if word.getParse().containsTag(MorphologicalTag.P3SG):
+            if not self.__contains_mode(wordIndex):
+                output.append(self.__with_tabs(tabCount + 1, "o:poss"))
+        if word.getParse().containsTag(MorphologicalTag.P3PL):
+            if not self.__contains_mode(wordIndex):
+                output.append(self.__with_tabs(tabCount + 1, "onlar:poss"))
+
+    def __is_month(self, next: str) -> bool:
+        return next in ["ocak", "şubat", "mart", "nisan", "mayıs", "haziran", "temmuz", "ağustos",
+                "eylül", "ekim", "kasım", "aralık"]
+
+    def __is_weekday(self, next: str) -> bool:
+        return next in ["pazartesi", "salı", "çarşamba", "perşembe", "cuma", "cumartesi", "pazar"]
+
+    def __is_ordinal(self, next: str) -> int:
+        if next == "birinci":
+            return 1
+        elif next == "ikinci":
+            return 2
+        elif next == "üçüncü":
+            return 3
+        elif next == "dördüncü":
+            return 4
+        elif next == "beşinci":
+            return 5
+        elif next == "altıncı":
+            return 6
+        elif next == "yedinci":
+            return 7
+        elif next == "sekizinci":
+            return 8
+        elif next == "dokuzuncu":
+            return 9
+        return 0
+
+    def __add_argument_list(self, output: List[str], current: AnnotatedWord, semantic: str, currentText: str) -> bool:
+        if current.getArgumentList() is not None:
+            argument_list = current.getArgumentList()
+            if argument_list.containsArgument("ARG0", semantic):
+                output.append(currentText + ":ARG0")
+                return True
+            elif argument_list.containsArgument("ARG1", semantic):
+                output.append(currentText + ":ARG1")
+                return True
+            elif argument_list.containsArgument("ARG2", semantic):
+                output.append(currentText + ":ARG2")
+                return True
+        return False
+
+    def __add_details(self, tabCount: int, output: List[str], current: AnnotatedWord, wordIndex: int) -> bool:
+        if current.getParse().containsTag(MorphologicalTag.NEGATIVE):
+            output.append(self.__with_tabs(tabCount + 1, ":polarity"))
+        self.__extra_args(output, current, tabCount)
+        self.__extra_possessive(output, current, wordIndex, tabCount)
+        if current.getParse().containsTag(MorphologicalTag.IMPERATIVE):
+            output.append(self.__with_tabs(tabCount + 1, ":imperative:mode"))
+
+    def __get_preliminary_extra(self, current: AnnotatedWord, index: int, added: List[str]) -> int:
+        added.append("")
+        if current.getParse().containsTag(MorphologicalTag.CONDITIONAL):
+            added[0] = ":cond"
+        for i in range(self.__sentence.wordCount()):
+            word = self.__sentence.getWord(i)
+            if isinstance(word, AnnotatedWord) and word.getUniversalDependency() is not None and word.getUniversalDependency().to() == index + 1:
+                if word.getParse().getWord().getName() == "kadar":
+                    added[0] = ":extent"
+                    return i
+                elif word.getParse().getWord().getName() in ["rağmen", "karşın", "karşılık"]:
+                    added[0] = ":concession"
+                    return i
+                elif word.getParse().getWord().getName() in ["için", "sayesinde", "dolayı"]:
+                    added[0] = ":cause"
+                    return i
+        return -1
+
+    def __add_default_case(self, done: List[bool], tabCount: int, output: List[str], defaultString: str, extraAdded: str, added: str, addedIndex: int):
+        if extraAdded != "":
+            output.append(self.__with_tabs(tabCount, defaultString + extraAdded))
+        else:
+            output.append(self.__with_tabs(tabCount, defaultString + added))
+            if addedIndex != -1:
+                done[addedIndex] = True
+
+    def __print_amr_recursively(self, done: List[bool], index: int, tabCount: int, output: List[str], relation: str, semantic: str, wordNet: WordNet, extraAdded: str):
+        current_word_index = index
+        if done[index]:
+            return
+        done[index] = True
+        current = self.__sentence.getWord(index)
+        if isinstance(current, AnnotatedWord):
+            if relation == "DET" and current.getParse().getWord().getName() == "bir":
+                return
+            if current.getParse().getWord().getName() in ["ve", "veya", "hem", "ama"]:
+                return
+            if current.getParse().getWord().getName() == "değil":
+                output.append(self.__with_tabs(tabCount, "-:polarity"))
+                return
+            if current.isPunctuation():
+                return
+            added = [""]
+            added_index = self.__get_preliminary_extra(current, index, added)
+            if current.getParse().isCardinal() and index + 1 < self.__sentence.wordCount():
+                next_word = self.__sentence.getWord(index + 1)
+                if isinstance(next_word, AnnotatedWord):
+                    next = next_word.getParse().getWord().getName()
+                    if self.__is_month(next):
+                        output.append(self.__with_tabs(tabCount, "date-entity:date"))
+                        output.append(self.__with_tabs(tabCount + 1, self.__only_word(current, index) + ":day"))
+                        output.append(self.__with_tabs(tabCount + 1, self.__only_word(next_word, index + 1) + ":month"))
+                    else:
+                        self.__add_default_case(done, tabCount, output, self.__only_word(current, index), extraAdded, added[0], added_index)
+            elif current.getParse().isProperNoun():
+                wiki_type = "person"
+                synsets = wordNet.getSynSetsWithLiteral(current.getParse().getWord().getName())
+                for synset in synsets:
+                    if isinstance(synset, SynSet) and synset.containsRelation(SemanticRelation("TUR10-0820020", "INSTANCE_HYPERNYM")):
+                        wiki_type = "city"
+                argument_added = self.__add_argument_list(output, current, semantic, self.__with_tabs(tabCount, wiki_type))
+                if not argument_added:
+                    if not current.getParse().getRootPos() == "VERB" and current.getParse().containsTag(MorphologicalTag.INSTRUMENTAL):
+                        output.append(self.__with_tabs(tabCount, wiki_type) + ":instrument")
+                    elif not current.getParse().getRootPos() == "VERB" and current.getParse().containsTag(MorphologicalTag.LOCATIVE):
+                        output.append(self.__with_tabs(tabCount, wiki_type) + ":location")
+                    else:
+                        self.__add_default_case(done, tabCount, output, self.__with_tabs(tabCount, wiki_type), extraAdded, added[0], added_index)
+                output.append(self.__with_tabs(tabCount + 1, "name:name"))
+                output.append(self.__with_tabs(tabCount + 2, self.__only_word(current, index) + ":op1"))
+                for i in range(1, 3):
+                    if index + i < self.__sentence.wordCount():
+                        check_word = self.__sentence.getWord(index + i)
+                        if isinstance(check_word, AnnotatedWord):
+                            if check_word.getSemantic() is not None and check_word.getSemantic() == current.getSemantic():
+                                output.append(self.__with_tabs(tabCount + 2, self.__only_word(check_word, index + 1) + ":op1" + str(1 + i)))
+                                done[index + i] = True
+                            else:
+                                break
+                    else:
+                        break
+                if wiki_type == "person":
+                    output.append(self.__with_tabs(tabCount + 1, "-:wiki"))
+                else:
+                    output.append(self.__with_tabs(tabCount + 1, current.getParse().getWord().getName() + "-:wiki"))
+            elif self.__is_month(current.getParse().getWord().getName()):
+                output.append(self.__with_tabs(tabCount, "date-entity:date"))
+                output.append(self.__with_tabs(tabCount + 1, self.__only_word(current, index) + ":month"))
+            elif self.__is_weekday(current.getParse().getWord().getName()):
+                output.append(self.__with_tabs(tabCount, "date-entity:date"))
+                output.append(self.__with_tabs(tabCount + 1, self.__only_word(current, index) + ":weekday"))
+            else:
+                current_word = self.__only_word(current, index)
+                for i in range(1, 3):
+                    if index > i - 1 and index - i < self.__sentence.wordCount() and not done[index - i]:
+                        check_word = self.__sentence.getWord(index - i)
+                        if isinstance(check_word, AnnotatedWord):
+                            if check_word.getSemantic() is not None and check_word.getSemantic() == current.getSemantic():
+                                current_word = self.__only_word(check_word, index - i) + " " + current_word
+                                done[index - i] = True
+                            else:
+                                break
+                    else:
+                        break
+                for i in range(1, 3):
+                    if index + i < self.__sentence.wordCount():
+                        check_word = self.__sentence.getWord(index + i)
+                        if isinstance(check_word, AnnotatedWord):
+                            if check_word.getSemantic() is not None and check_word.getSemantic() == current.getSemantic():
+                                current_word += " " + self.__only_word(check_word, index + i)
+                                done[index + i] = True
+                                current = check_word
+                                current_word_index = index + i
+                            else:
+                                break
+                    else:
+                        break
+                if current.getParse().getWord().getName() in ["çok", "gayet", "tam", "bayağı", "fazla", "hiç"]:
+                    output.append(self.__with_tabs(tabCount, current_word) + ":degree")
+                elif current.getParse().getWord().getName() in ["hep", "sürekli"]:
+                    output.append(self.__with_tabs(tabCount, current_word) + ":frequency")
+                else:
+                    argument_added = self.__add_argument_list(output, current, semantic, self.__with_tabs(tabCount, current_word))
+                    if argument_added:
+                        self.__add_details(tabCount, output, current, current_word_index)
+                    elif current.getParse().containsTag(MorphologicalTag.ORDINAL) or self.__is_ordinal(current.getParse().getWord().getName()) > 0:
+                        output.append(self.__with_tabs(tabCount, "ordinal-entity:ord"))
+                        value = self.__is_ordinal(current.getParse().getWord().getName())
+                        if value > 0:
+                            output.append(self.__with_tabs(tabCount + 1, str(value) + ":value"))
+                        else:
+                            output.append(self.__with_tabs(tabCount + 1, current.getParse().getWord().getName() + ":value"))
+                    else:
+                        if relation == "AMOD" or relation == "NMOD":
+                            output.append(self.__with_tabs(tabCount, current_word) + ":mod")
+                        elif relation == "NUMMOD":
+                            output.append(self.__with_tabs(tabCount, current_word) + ":quant")
+                        elif relation == "ADVMOD":
+                            output.append(self.__with_tabs(tabCount, current_word) + ":manner")
+                        else:
+                            if current.getParse().getRootPos() != "VERB" and current.getParse().containsTag(
+                                    MorphologicalTag.INSTRUMENTAL):
+                                output.append(self.__with_tabs(tabCount, current_word) + ":instrument")
+                            elif current.getParse().getRootPos() != "VERB" and current.getParse().containsTag(
+                                    MorphologicalTag.LOCATIVE):
+                                output.append(self.__with_tabs(tabCount, current_word) + ":location")
+                            else:
+                                self.__add_default_case(done, tabCount, output, self.__with_tabs(tabCount, current_word), extraAdded, added[0], added_index)
+                                self.__add_details(tabCount, output, current, current_word_index)
+        i = 0
+        while i < self.__sentence.wordCount():
+            word = self.__sentence.getWord(i)
+            if isinstance(word, AnnotatedWord):
+                if word.getParse().isCardinal() and i + 1 < self.__sentence.wordCount():
+                    next_word = self.__sentence.getWord(i + 1)
+                    if isinstance(next_word, AnnotatedWord):
+                        next = next_word.getParse().getWord().getName()
+                        if self.__is_month(next):
+                            if next_word.getUniversalDependency().to() == index + 1:
+                                self.__meta_verb_tags(word, done, i, tabCount + 1, output, word.getUniversalDependency().__str__(), current.getSemantic(), wordNet)
+                            i = i + 2
+                            continue
+                j = i
+                while i < self.__sentence.wordCount() - 1 and self.__sentence.getWord(i + 1).getSemantic() is not None and self.__sentence.getWord(i + 1).getSemantic() == word.getSemantic():
+                    i = i + 1
+                if word.getUniversalDependency() is not None and word.getUniversalDependency().to() == index + 1:
+                    self.__meta_verb_tags(word, done, j, tabCount + 1, output, word.getUniversalDependency().__str__(), current.getSemantic(), wordNet)
+                elif j != i and self.__sentence.getWord(i).getUniversalDependency() is not None and self.__sentence.getWord(i).getUniversalDependency().to() == index + 1:
+                    self.__meta_verb_tags(word, done, j, tabCount + 1, output, word.getUniversalDependency().__str__(), current.getSemantic(), wordNet)
+            i = i + 1
+
+    def __meta_verb_tags(self, word: AnnotatedWord, done: List[bool], index: int, tabCount: int, output: List[str], relation: str, semantic: str, wordNet: WordNet):
+        parataxis_or_conj = False
+        for i in range(self.__sentence.wordCount()):
+            connected_word = self.__sentence.getWord(i)
+            if isinstance(connected_word, AnnotatedWord):
+                if connected_word.getUniversalDependency() is not None and connected_word.getUniversalDependency().to() == index + 1 and connected_word.getUniversalDependency().__str__() in ["PARATAXIS", "CONJ"]:
+                    parataxis_or_conj = True
+                    break
+        if parataxis_or_conj:
+            output.append(self.__with_tabs(tabCount, "and"))
+            count = 1
+            for i in range(self.__sentence.wordCount()):
+                connected_word = self.__sentence.getWord(i)
+                if isinstance(connected_word, AnnotatedWord):
+                    if connected_word.getUniversalDependency() is not None and connected_word.getUniversalDependency().to() == index + 1 and connected_word.getUniversalDependency().__str__() in ["PARATAXIS", "CONJ"]:
+                        self.__print_amr_recursively(done, i, tabCount + 1, output, relation, semantic, wordNet, ":op" + str(count))
+                        count = count + 1
+            self.__print_amr_recursively(done, index, tabCount + 1, output, relation, semantic, wordNet, ":op" + str(count))
+        else:
+            if word.getParse().containsTag(MorphologicalTag.NECESSITY):
+                output.append(self.__with_tabs(tabCount, "öner"))
+                tabCount = tabCount + 1
+            if word.getParse().containsTag(MorphologicalTag.ABLE):
+                output.append(self.__with_tabs(tabCount, "mümkün"))
+                tabCount = tabCount + 1
+            if word.getParse().containsTag(MorphologicalTag.CAUSATIVE):
+                output.append(self.__with_tabs(tabCount, "yap"))
+                tabCount = tabCount + 1
+            self.__print_amr_recursively(done, index, tabCount, output, relation, semantic, wordNet,"")
+
+    def constructExcelAmr(self, sentence: AnnotatedSentence) -> list[str]:
+        output = []
+        self.__sentence = sentence
+        done = []
+        for i in range(self.__sentence.wordCount()):
+            done.append(False)
+        output.append(sentence.getFileName() + "\t" + sentence.toString())
+        for i in range(sentence.wordCount()):
+            word = sentence.getWord(i)
+            if isinstance(word, AnnotatedWord):
+                if word.getUniversalDependency() is not None and word.getUniversalDependency().__str__() == "ROOT":
+                    self.__meta_verb_tags(word, done, i, 0, output, "ROOT", word.getSemantic(), self.__word_net)
+        return output

nlptoolkit_amr-1.0.0/Corpus/AmrConnection.py

@@ -0,0 +1,21 @@
+from AmrWord import AmrWord
+
+class AmrConnection:
+
+    __from : AmrWord
+    __to: AmrWord
+    __with: str
+
+    def __init__(self, _from: AmrWord, _to: AmrWord, _with: str):
+        self.__from = _from
+        self.__to = _to
+        self.__with = _with
+
+    def getFrom(self) -> AmrWord:
+        return self.__from
+
+    def getTo(self) -> AmrWord:
+        return self.__to
+
+    def getWith(self) -> str:
+        return self.__with

nlptoolkit_amr-1.0.0/Corpus/AmrCorpus.py

@@ -0,0 +1,32 @@
+import os
+import re
+
+from Corpus.Corpus import Corpus
+
+from AmrSentence import AmrSentence
+
+
+class AmrCorpus(Corpus):
+
+    def __init__(self,
+                 folder: str,
+                 pattern: str = None):
+        """
+        A constructor of AmrCorpus class which reads all AmrSentence files with the file
+        name satisfying the given pattern inside the given folder. For each file inside that folder, the constructor
+        creates an AmrSentence and puts in inside the list sentences.
+
+        PARAMETERS
+        ----------
+        folder : str
+            Folder where all sentences reside.
+        pattern : str
+            File pattern such as "." ".train" ".test".
+        """
+        self.sentences = []
+        for root, dirs, files in os.walk(folder):
+            for file in files:
+                file_name = os.path.join(root, file)
+                if (pattern is None or pattern in file_name) and re.match("\\d+\\.", file):
+                    sentence = AmrSentence(root, file_name)
+                    self.sentences.append(sentence)

nlptoolkit_amr-1.0.0/Corpus/AmrSentence.py

@@ -0,0 +1,101 @@
+import xml.etree.ElementTree
+
+from Corpus.FileDescription import FileDescription
+from Corpus.Sentence import Sentence
+
+from AmrConnection import AmrConnection
+from AmrWord import AmrWord
+from Point import Point
+
+
+class AmrSentence(Sentence):
+
+    __connections: list[AmrConnection]
+    __file_description: FileDescription
+
+    def constructor1(self, file_description: FileDescription):
+        self.__file_description = file_description
+        self.reload()
+
+    def constructor2(self, path: str, file_name: str):
+        self.__file_description = FileDescription(path, file_name)
+        self.reload()
+
+    def __init__(self, param1: str | FileDescription, param2: str | None = None):
+        self.words = []
+        self.__connections = []
+        if param2 is not None and isinstance(param1, str):
+            self.constructor2(param1, param2)
+        elif isinstance(param1, FileDescription):
+            self.constructor1(param1)
+
+    def reload(self):
+        file_name = self.__file_description.getFileName()
+        root = xml.etree.ElementTree.parse(file_name).getroot()
+        self.__load_from_xml(root)
+
+    def getRawFileName(self) -> str:
+        return self.__file_description.getRawFileName()
+
+    def getFileName(self) -> str:
+        return self.__file_description.getFileName()
+
+    def getFileDescription(self) -> FileDescription:
+        return self.__file_description
+
+    def __getWord(self, name: str) -> AmrWord | None:
+        for word in self.words:
+            if word.getName() == name:
+                return word
+        return None
+
+    def getConnection(self, index: int) -> AmrConnection:
+        return self.__connections[index]
+
+    def connection_count(self) -> int:
+        return len(self.__connections)
+
+    def add_connection(self, _from: AmrWord, _to: AmrWord, _with: str):
+        self.__connections.append(AmrConnection(_from, _to, _with))
+
+    def __load_from_xml(self, root):
+        for child_node in root:
+            if child_node.tag == "Word":
+                new_word = AmrWord(child_node.attrib["name"], Point(child_node.attrib["positionX"], child_node.attrib["positionY"]))
+                self.addWord(new_word)
+            elif child_node.tag == "Connection":
+                _from = self.__getWord(child_node.attrib["from"])
+                _to = self.__getWord(child_node.attrib["to"])
+                if child_node.attrib["with"] is not None:
+                    _with = child_node.attrib["with"]
+                else:
+                    _with = ""
+                if _from is not None and _to is not None:
+                    self.add_connection(_from, _to, _with)
+
+    def __get_root(self) -> AmrWord | None:
+        done = set()
+        for word in self.words:
+            done.add(word.getName())
+        for connection in self.__connections:
+            if connection.getTo().getName() in done:
+                done.remove(connection.getTo().getName())
+        return self.__getWord(done.pop())
+
+    def __word_to_string(self, word: AmrWord | None, tab_count: int) -> str:
+        result = "(" + word.getName()
+        for connection in self.__connections:
+            if connection.getFrom().getName() == word.getName():
+                child = "\n"
+                for i in range(tab_count + 1):
+                    child += "\t"
+                child += ":" + connection.getWith()
+                child += " " + self.__word_to_string(connection.getTo(), tab_count + 1)
+                result += child
+        return result + ")"
+
+    def __repr__(self):
+        return self.getFileName() + "\n" + self.__word_to_string(self.__get_root(), 0)
+
+    def __str__(self):
+        return self.__repr__()

nlptoolkit_amr-1.0.0/Corpus/AmrWord.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from Dictionary.Word import Word
+from Point import Point
+
+class AmrWord(Word):
+
+    position: Point
+
+    def __init__(self, name: str, position:Point):
+        super().__init__(name)
+        self.position = position
+
+    def getPosition(self) -> Point:
+        return self.position
+
+    def move(self, deltaX: int, deltaY: int) -> None:
+        self.position.setX(self.getPosition().getX() + deltaX)
+        self.position.setY(self.getPosition().getY() + deltaY)
+
+    def clone(self) -> AmrWord:
+        return AmrWord(self.getName(), Point(self.getPosition().getX(), self.getPosition().getY()))

nlptoolkit_amr-1.0.0/Corpus/Point.py

@@ -0,0 +1,20 @@
+class Point:
+
+    __x: int
+    __y: int
+
+    def __init__(self, x: int,y: int):
+        self.__x = x
+        self.__y = y
+
+    def getX(self) -> int:
+        return self.__x
+
+    def getY(self) -> int:
+        return self.__y
+
+    def setX(self, x):
+        self.__x = x
+
+    def setY(self, y):
+        self.__y = y

nlptoolkit_amr-1.0.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: nlptoolkit_amr
+Version: 1.0.0
+Summary: Simple Amr Processing
+Home-page: https://github.com/StarlangSoftware/Amr-Py
+Author: olcaytaner
+Author-email: olcay.yildiz@ozyegin.edu.tr
+License: UNKNOWN
+Description: For Contibutors
+        ============
+        
+        ### Setup.py file
+        1. Do not forget to set package list. All subfolders should be added to the package list.
+        ```
+            packages=['Classification', 'Classification.Model', 'Classification.Model.DecisionTree',
+                      'Classification.Model.Ensemble', 'Classification.Model.NeuralNetwork',
+                      'Classification.Model.NonParametric', 'Classification.Model.Parametric',
+                      'Classification.Filter', 'Classification.DataSet', 'Classification.Instance', 'Classification.Attribute',
+                      'Classification.Parameter', 'Classification.Experiment',
+                      'Classification.Performance', 'Classification.InstanceList', 'Classification.DistanceMetric',
+                      'Classification.StatisticalTest', 'Classification.FeatureSelection'],
+        ```
+        2. Package name should be lowercase and only may include _ character.
+        ```
+            name='nlptoolkit_math',
+        ```
+        
+        ### Python files
+        1. Do not forget to comment each function.
+        ```
+            def __broadcast_shape(self, shape1: Tuple[int, ...], shape2: Tuple[int, ...]) -> Tuple[int, ...]:
+                """
+                Determines the broadcasted shape of two tensors.
+        
+                :param shape1: Tuple representing the first tensor shape.
+                :param shape2: Tuple representing the second tensor shape.
+                :return: Tuple representing the broadcasted shape.
+                """
+        ```
+        2. Function names should follow caml case.
+        ```
+            def addItem(self, item: str):
+        ```
+        3. Local variables should follow snake case.
+        ```
+        	det = 1.0
+        	copy_of_matrix = copy.deepcopy(self)
+        ```
+        4. Class variables should be declared in each file.
+        ```
+        class Eigenvector(Vector):
+            eigenvalue: float
+        ```
+        5. Variable types should be defined for function parameters and class variables.
+        ```
+            def getIndex(self, item: str) -> int:
+        ```
+        6. For abstract methods, use ABC package and declare them with @abstractmethod.
+        ```
+            @abstractmethod
+            def train(self, train_set: list[Tensor]):
+                pass
+        ```
+        7. For private methods, use __ as prefix in their names.
+        ```
+            def __infer_shape(self, data: Union[List, List[List], List[List[List]]]) -> Tuple[int, ...]:
+        ```
+        8. For private class variables, use __ as prefix in their names.
+        ```
+        class Matrix(object):
+            __row: int
+            __col: int
+            __values: list[list[float]]
+        ```
+        9. Write \_\_repr\_\_ class methods as toString methods
+        10. Write getter and setter class methods.
+        ```
+            def getOptimizer(self) -> Optimizer:
+                return self.optimizer
+            def setValue(self, value: Optional[Tensor]) -> None:
+                self._value = value
+        ```
+        11. If there are multiple constructors for a class, define them as constructor1, constructor2, ..., then from the original constructor call these methods.
+        ```
+            def constructor1(self):
+                self.__values = []
+                self.__size = 0
+        
+            def constructor2(self, values: list):
+                self.__values = values.copy()
+                self.__size = len(values)
+        
+            def __init__(self,
+                         valuesOrSize=None,
+                         initial=None):
+                if valuesOrSize is None:
+                    self.constructor1()
+                elif isinstance(valuesOrSize, list):
+                    self.constructor2(valuesOrSize)
+        ```
+        12. Extend test classes from unittest and use separate unit test methods.
+        ```
+        class TensorTest(unittest.TestCase):
+        
+            def test_inferred_shape(self):
+                a = Tensor([[1.0, 2.0], [3.0, 4.0]])
+                self.assertEqual((2, 2), a.getShape())
+        
+            def test_shape(self):
+                a = Tensor([1.0, 2.0, 3.0])
+                self.assertEqual((3, ), a.getShape())
+        ```
+        13. Enumerated types should be used when necessary as enum classes.
+        ```
+        class AttributeType(Enum):
+            """
+            Continuous Attribute
+            """
+            CONTINUOUS = auto()
+            """
+            Discrete Attribute
+            """
+            DISCRETE = auto()
+        ```
+        
+Platform: UNKNOWN
+Description-Content-Type: text/markdown

nlptoolkit_amr-1.0.0/README.md

@@ -0,0 +1,116 @@
+For Contibutors
+============
+
+### Setup.py file
+1. Do not forget to set package list. All subfolders should be added to the package list.
+```
+    packages=['Classification', 'Classification.Model', 'Classification.Model.DecisionTree',
+              'Classification.Model.Ensemble', 'Classification.Model.NeuralNetwork',
+              'Classification.Model.NonParametric', 'Classification.Model.Parametric',
+              'Classification.Filter', 'Classification.DataSet', 'Classification.Instance', 'Classification.Attribute',
+              'Classification.Parameter', 'Classification.Experiment',
+              'Classification.Performance', 'Classification.InstanceList', 'Classification.DistanceMetric',
+              'Classification.StatisticalTest', 'Classification.FeatureSelection'],
+```
+2. Package name should be lowercase and only may include _ character.
+```
+    name='nlptoolkit_math',
+```
+
+### Python files
+1. Do not forget to comment each function.
+```
+    def __broadcast_shape(self, shape1: Tuple[int, ...], shape2: Tuple[int, ...]) -> Tuple[int, ...]:
+        """
+        Determines the broadcasted shape of two tensors.
+
+        :param shape1: Tuple representing the first tensor shape.
+        :param shape2: Tuple representing the second tensor shape.
+        :return: Tuple representing the broadcasted shape.
+        """
+```
+2. Function names should follow caml case.
+```
+    def addItem(self, item: str):
+```
+3. Local variables should follow snake case.
+```
+	det = 1.0
+	copy_of_matrix = copy.deepcopy(self)
+```
+4. Class variables should be declared in each file.
+```
+class Eigenvector(Vector):
+    eigenvalue: float
+```
+5. Variable types should be defined for function parameters and class variables.
+```
+    def getIndex(self, item: str) -> int:
+```
+6. For abstract methods, use ABC package and declare them with @abstractmethod.
+```
+    @abstractmethod
+    def train(self, train_set: list[Tensor]):
+        pass
+```
+7. For private methods, use __ as prefix in their names.
+```
+    def __infer_shape(self, data: Union[List, List[List], List[List[List]]]) -> Tuple[int, ...]:
+```
+8. For private class variables, use __ as prefix in their names.
+```
+class Matrix(object):
+    __row: int
+    __col: int
+    __values: list[list[float]]
+```
+9. Write \_\_repr\_\_ class methods as toString methods
+10. Write getter and setter class methods.
+```
+    def getOptimizer(self) -> Optimizer:
+        return self.optimizer
+    def setValue(self, value: Optional[Tensor]) -> None:
+        self._value = value
+```
+11. If there are multiple constructors for a class, define them as constructor1, constructor2, ..., then from the original constructor call these methods.
+```
+    def constructor1(self):
+        self.__values = []
+        self.__size = 0
+
+    def constructor2(self, values: list):
+        self.__values = values.copy()
+        self.__size = len(values)
+
+    def __init__(self,
+                 valuesOrSize=None,
+                 initial=None):
+        if valuesOrSize is None:
+            self.constructor1()
+        elif isinstance(valuesOrSize, list):
+            self.constructor2(valuesOrSize)
+```
+12. Extend test classes from unittest and use separate unit test methods.
+```
+class TensorTest(unittest.TestCase):
+
+    def test_inferred_shape(self):
+        a = Tensor([[1.0, 2.0], [3.0, 4.0]])
+        self.assertEqual((2, 2), a.getShape())
+
+    def test_shape(self):
+        a = Tensor([1.0, 2.0, 3.0])
+        self.assertEqual((3, ), a.getShape())
+```
+13. Enumerated types should be used when necessary as enum classes.
+```
+class AttributeType(Enum):
+    """
+    Continuous Attribute
+    """
+    CONTINUOUS = auto()
+    """
+    Discrete Attribute
+    """
+    DISCRETE = auto()
+```

nlptoolkit_amr-1.0.0/nlptoolkit_amr.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: nlptoolkit-amr
+Version: 1.0.0
+Summary: Simple Amr Processing
+Home-page: https://github.com/StarlangSoftware/Amr-Py
+Author: olcaytaner
+Author-email: olcay.yildiz@ozyegin.edu.tr
+License: UNKNOWN
+Description: For Contibutors
+        ============
+        
+        ### Setup.py file
+        1. Do not forget to set package list. All subfolders should be added to the package list.
+        ```
+            packages=['Classification', 'Classification.Model', 'Classification.Model.DecisionTree',
+                      'Classification.Model.Ensemble', 'Classification.Model.NeuralNetwork',
+                      'Classification.Model.NonParametric', 'Classification.Model.Parametric',
+                      'Classification.Filter', 'Classification.DataSet', 'Classification.Instance', 'Classification.Attribute',
+                      'Classification.Parameter', 'Classification.Experiment',
+                      'Classification.Performance', 'Classification.InstanceList', 'Classification.DistanceMetric',
+                      'Classification.StatisticalTest', 'Classification.FeatureSelection'],
+        ```
+        2. Package name should be lowercase and only may include _ character.
+        ```
+            name='nlptoolkit_math',
+        ```
+        
+        ### Python files
+        1. Do not forget to comment each function.
+        ```
+            def __broadcast_shape(self, shape1: Tuple[int, ...], shape2: Tuple[int, ...]) -> Tuple[int, ...]:
+                """
+                Determines the broadcasted shape of two tensors.
+        
+                :param shape1: Tuple representing the first tensor shape.
+                :param shape2: Tuple representing the second tensor shape.
+                :return: Tuple representing the broadcasted shape.
+                """
+        ```
+        2. Function names should follow caml case.
+        ```
+            def addItem(self, item: str):
+        ```
+        3. Local variables should follow snake case.
+        ```
+        	det = 1.0
+        	copy_of_matrix = copy.deepcopy(self)
+        ```
+        4. Class variables should be declared in each file.
+        ```
+        class Eigenvector(Vector):
+            eigenvalue: float
+        ```
+        5. Variable types should be defined for function parameters and class variables.
+        ```
+            def getIndex(self, item: str) -> int:
+        ```
+        6. For abstract methods, use ABC package and declare them with @abstractmethod.
+        ```
+            @abstractmethod
+            def train(self, train_set: list[Tensor]):
+                pass
+        ```
+        7. For private methods, use __ as prefix in their names.
+        ```
+            def __infer_shape(self, data: Union[List, List[List], List[List[List]]]) -> Tuple[int, ...]:
+        ```
+        8. For private class variables, use __ as prefix in their names.
+        ```
+        class Matrix(object):
+            __row: int
+            __col: int
+            __values: list[list[float]]
+        ```
+        9. Write \_\_repr\_\_ class methods as toString methods
+        10. Write getter and setter class methods.
+        ```
+            def getOptimizer(self) -> Optimizer:
+                return self.optimizer
+            def setValue(self, value: Optional[Tensor]) -> None:
+                self._value = value
+        ```
+        11. If there are multiple constructors for a class, define them as constructor1, constructor2, ..., then from the original constructor call these methods.
+        ```
+            def constructor1(self):
+                self.__values = []
+                self.__size = 0
+        
+            def constructor2(self, values: list):
+                self.__values = values.copy()
+                self.__size = len(values)
+        
+            def __init__(self,
+                         valuesOrSize=None,
+                         initial=None):
+                if valuesOrSize is None:
+                    self.constructor1()
+                elif isinstance(valuesOrSize, list):
+                    self.constructor2(valuesOrSize)
+        ```
+        12. Extend test classes from unittest and use separate unit test methods.
+        ```
+        class TensorTest(unittest.TestCase):
+        
+            def test_inferred_shape(self):
+                a = Tensor([[1.0, 2.0], [3.0, 4.0]])
+                self.assertEqual((2, 2), a.getShape())
+        
+            def test_shape(self):
+                a = Tensor([1.0, 2.0, 3.0])
+                self.assertEqual((3, ), a.getShape())
+        ```
+        13. Enumerated types should be used when necessary as enum classes.
+        ```
+        class AttributeType(Enum):
+            """
+            Continuous Attribute
+            """
+            CONTINUOUS = auto()
+            """
+            Discrete Attribute
+            """
+            DISCRETE = auto()
+        ```
+        
+Platform: UNKNOWN
+Description-Content-Type: text/markdown

nlptoolkit_amr-1.0.0/nlptoolkit_amr.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+setup.py
+Construction/AmrConstructionAlgorithm.py
+Construction/RuleBasedConstructionAlgorithm.py
+Corpus/AmrConnection.py
+Corpus/AmrCorpus.py
+Corpus/AmrSentence.py
+Corpus/AmrWord.py
+Corpus/Point.py
+nlptoolkit_amr.egg-info/PKG-INFO
+nlptoolkit_amr.egg-info/SOURCES.txt
+nlptoolkit_amr.egg-info/dependency_links.txt
+nlptoolkit_amr.egg-info/requires.txt
+nlptoolkit_amr.egg-info/top_level.txt

nlptoolkit_amr-1.0.0/nlptoolkit_amr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nlptoolkit_amr-1.0.0/nlptoolkit_amr.egg-info/requires.txt

@@ -0,0 +1 @@
+NlpToolkit-AnnotatedSentence

nlptoolkit_amr-1.0.0/nlptoolkit_amr.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+Construction
+Corpus

nlptoolkit_amr-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nlptoolkit_amr-1.0.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup
+
+from pathlib import Path
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name='nlptoolkit_amr',
+    version='1.0.0',
+    packages=['Corpus', 'Construction'],
+    url='https://github.com/StarlangSoftware/Amr-Py',
+    license='',
+    author='olcaytaner',
+    author_email='olcay.yildiz@ozyegin.edu.tr',
+    description='Simple Amr Processing',
+    install_requires=['NlpToolkit-AnnotatedSentence'],
+    long_description=long_description,
+    long_description_content_type='text/markdown'
+)