nlptoolkit-annotatedtree 1.0.0

package/source/Processor/Condition/IsPunctuationNode.ts

@@ -0,0 +1,16 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {Word} from "nlptoolkit-dictionary/dist/Dictionary/Word";
+
+export class IsPunctuationNode extends IsLeafNode{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let data = parseNode.getLayerData(ViewLayerType.ENGLISH_WORD);
+            return Word.isPunctuation(data) && data != "$";
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsTransferable.ts

@@ -0,0 +1,26 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {IsNoneNode} from "./IsNoneNode";
+import {IsNullElement} from "./IsNullElement";
+
+export class IsTransferable extends IsLeafNode{
+
+    private secondLanguage: ViewLayerType
+
+    constructor(secondLanguage: ViewLayerType) {
+        super();
+        this.secondLanguage = secondLanguage
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)) {
+            if (new IsNoneNode(this.secondLanguage).satisfies(parseNode)){
+                return false;
+            }
+            return !new IsNullElement().satisfies(parseNode);
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsTurkishLeafNode.ts

@@ -0,0 +1,16 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class IsTurkishLeafNode extends IsLeafNode{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        if (super.satisfies(parseNode)){
+            let data = parseNode.getLayerInfo().getLayerData(ViewLayerType.TURKISH_WORD);
+            let parentData = parseNode.getParent().getData().getName();
+            return data != null && !data.includes("*") && !(data == "0" && parentData == "-NONE-");
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/IsVPNode.ts

@@ -0,0 +1,10 @@
+import {NodeDrawableCondition} from "./NodeDrawableCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class IsVPNode implements NodeDrawableCondition{
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        return parseNode.numberOfChildren() > 0 && parseNode.getData().isVP();
+    }
+
+}

package/source/Processor/Condition/IsVerbNode.ts

@@ -0,0 +1,29 @@
+import {IsLeafNode} from "./IsLeafNode";
+import {WordNet} from "nlptoolkit-wordnet/dist/WordNet";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {Pos} from "nlptoolkit-dictionary/dist/Dictionary/Pos";
+
+export class IsVerbNode extends IsLeafNode{
+
+    private wordNet: WordNet
+
+    constructor(wordNet: WordNet) {
+        super();
+        this.wordNet = wordNet
+    }
+
+    satisfies(parseNode: ParseNodeDrawable): boolean {
+        let layerInfo = parseNode.getLayerInfo();
+        if (super.satisfies(parseNode) && layerInfo != null && layerInfo.getLayerData(ViewLayerType.SEMANTICS) != null){
+            for (let i = 0; i < layerInfo.getNumberOfMeanings(); i++){
+                let synSetId = layerInfo.getSemanticAt(i);
+                if (this.wordNet.getSynSetWithId(synSetId) != null && this.wordNet.getSynSetWithId(synSetId).getPos() == Pos.VERB){
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+}

package/source/Processor/Condition/NodeDrawableCondition.ts

@@ -0,0 +1,6 @@
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export interface NodeDrawableCondition {
+
+    satisfies(parseNode: ParseNodeDrawable): boolean
+}

package/source/Processor/LayerExist/ContainsLayerInformation.ts

@@ -0,0 +1,38 @@
+import {LeafListCondition} from "./LeafListCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {IsTurkishLeafNode} from "../Condition/IsTurkishLeafNode";
+
+export class ContainsLayerInformation implements LeafListCondition{
+
+    private readonly viewLayerType: ViewLayerType
+
+    constructor(viewLayerType: ViewLayerType) {
+        this.viewLayerType = viewLayerType
+    }
+
+    satisfies(leafList: Array<ParseNodeDrawable>): boolean {
+        for (let parseNode of leafList){
+            if (!parseNode.getLayerData(ViewLayerType.ENGLISH_WORD).includes("*")){
+                switch (this.viewLayerType){
+                    case ViewLayerType.TURKISH_WORD:
+                        if (parseNode.getLayerData(this.viewLayerType) == null){
+                            return false;
+                        }
+                        break;
+                    case ViewLayerType.PART_OF_SPEECH:
+                    case ViewLayerType.INFLECTIONAL_GROUP:
+                    case ViewLayerType.NER:
+                    case ViewLayerType.SEMANTICS:
+                    case ViewLayerType.PROPBANK:
+                        if (parseNode.getLayerData(this.viewLayerType) == null && new IsTurkishLeafNode().satisfies(parseNode)){
+                            return false;
+                        }
+                        break;
+                }
+            }
+        }
+        return true;
+    }
+
+}

package/source/Processor/LayerExist/LeafListCondition.ts

@@ -0,0 +1,6 @@
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export interface LeafListCondition {
+
+    satisfies(leafList: Array<ParseNodeDrawable>): boolean
+}

package/source/Processor/LayerExist/NotContainsLayerInformation.ts

@@ -0,0 +1,37 @@
+import {LeafListCondition} from "./LeafListCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {IsTurkishLeafNode} from "../Condition/IsTurkishLeafNode";
+
+export class NotContainsLayerInformation implements LeafListCondition{
+
+    private readonly viewLayerType: ViewLayerType
+
+    constructor(viewLayerType: ViewLayerType) {
+        this.viewLayerType = viewLayerType
+    }
+
+    satisfies(leafList: Array<ParseNodeDrawable>): boolean {
+        for (let parseNode of leafList){
+            if (!parseNode.getLayerData(ViewLayerType.ENGLISH_WORD).includes("*")) {
+                switch (this.viewLayerType){
+                    case ViewLayerType.TURKISH_WORD:
+                        if (parseNode.getLayerData(this.viewLayerType) != null){
+                            return false;
+                        }
+                        break;
+                    case ViewLayerType.PART_OF_SPEECH:
+                    case ViewLayerType.INFLECTIONAL_GROUP:
+                    case ViewLayerType.NER:
+                    case ViewLayerType.SEMANTICS:
+                        if (parseNode.getLayerData(this.viewLayerType) != null && new IsTurkishLeafNode().satisfies(parseNode)){
+                            return false;
+                        }
+                        break;
+                }
+            }
+        }
+        return true;
+    }
+
+}

package/source/Processor/LayerExist/SemiContainsLayerInformation.ts

@@ -0,0 +1,44 @@
+import {LeafListCondition} from "./LeafListCondition";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {IsTurkishLeafNode} from "../Condition/IsTurkishLeafNode";
+
+export class SemiContainsLayerInformation implements LeafListCondition{
+
+    private readonly viewLayerType: ViewLayerType
+
+    constructor(viewLayerType: ViewLayerType) {
+        this.viewLayerType = viewLayerType
+    }
+
+    satisfies(leafList: Array<ParseNodeDrawable>): boolean {
+        let notDone = 0, done = 0;
+        for (let parseNode of leafList){
+            if (!parseNode.getLayerData(ViewLayerType.ENGLISH_WORD).includes("*")) {
+                switch (this.viewLayerType){
+                    case ViewLayerType.TURKISH_WORD:
+                        if (parseNode.getLayerData(this.viewLayerType) != null){
+                            done++;
+                        } else {
+                            notDone++;
+                        }
+                        break;
+                    case ViewLayerType.PART_OF_SPEECH:
+                    case ViewLayerType.INFLECTIONAL_GROUP:
+                    case ViewLayerType.NER:
+                    case ViewLayerType.SEMANTICS:
+                        if (new IsTurkishLeafNode().satisfies(parseNode)){
+                            if (parseNode.getLayerData(this.viewLayerType) != null){
+                                done++;
+                            } else {
+                                notDone++;
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        return done != 0 && notDone != 0;
+    }
+
+}

package/source/Processor/LeafConverter/LeafToEnglish.ts

@@ -0,0 +1,11 @@
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import {LeafToLanguageConverter} from "./LeafToLanguageConverter";
+
+export class LeafToEnglish extends LeafToLanguageConverter{
+
+    constructor() {
+        super()
+        this.viewLayerType = ViewLayerType.ENGLISH_WORD;
+    }
+
+}

package/source/Processor/LeafConverter/LeafToLanguageConverter.ts

@@ -0,0 +1,35 @@
+import {LeafToStringConverter} from "./LeafToStringConverter";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class LeafToLanguageConverter implements LeafToStringConverter{
+
+    protected viewLayerType: ViewLayerType
+
+    leafConverter(leafNode: ParseNodeDrawable): string {
+        let layerData = leafNode.getLayerData(this.viewLayerType);
+        let parentLayerData = (<ParseNodeDrawable>leafNode.getParent()).getLayerData(this.viewLayerType);
+        if (layerData != null){
+            if (layerData.includes("*") || (layerData == "0" && parentLayerData == "-NONE-")){
+                return "";
+            } else {
+                return " " + layerData
+                    .replace("-LRB-", "(")
+                    .replace("-RRB-", ")")
+                    .replace("-LSB-", "[")
+                    .replace("-RSB-", "]")
+                    .replace("-LCB-", "{")
+                    .replace("-RCB-", "}")
+                    .replace("-lrb-", "(")
+                    .replace("-rrb-", ")")
+                    .replace("-lsb-", "[")
+                    .replace("-rsb-", "]")
+                    .replace("-lcb-", "{")
+                    .replace("-rcb-", "}");
+            }
+        } else {
+            return "";
+        }
+    }
+
+}

package/source/Processor/LeafConverter/LeafToPersian.ts

@@ -0,0 +1,10 @@
+import {LeafToLanguageConverter} from "./LeafToLanguageConverter";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class LeafToPersian extends LeafToLanguageConverter{
+
+    constructor() {
+        super();
+        this.viewLayerType = ViewLayerType.PERSIAN_WORD
+    }
+}

package/source/Processor/LeafConverter/LeafToRootFormConverter.ts

@@ -0,0 +1,18 @@
+import {LeafToStringConverter} from "./LeafToStringConverter";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export class LeafToRootFormConverter implements LeafToStringConverter{
+
+    leafConverter(parseNodeDrawable: ParseNodeDrawable): string {
+        let layerInfo = parseNodeDrawable.getLayerInfo();
+        let rootWords = " ";
+        for (let i = 0; i < layerInfo.getNumberOfWords(); i++) {
+            let root = layerInfo.getMorphologicalParseAt(i).getWord().getName();
+            if (root != null && root != ""){
+                rootWords += " " + root;
+            }
+        }
+        return rootWords.toString();
+    }
+
+}

package/source/Processor/LeafConverter/LeafToStringConverter.ts

@@ -0,0 +1,6 @@
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export interface LeafToStringConverter {
+
+    leafConverter(leafNode: ParseNodeDrawable): string
+}

package/source/Processor/LeafConverter/LeafToTurkish.ts

@@ -0,0 +1,10 @@
+import {LeafToLanguageConverter} from "./LeafToLanguageConverter";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class LeafToTurkish extends LeafToLanguageConverter{
+
+    constructor() {
+        super();
+        this.viewLayerType = ViewLayerType.TURKISH_WORD
+    }
+}

package/source/Processor/NodeDrawableCollector.ts

@@ -0,0 +1,28 @@
+import {NodeDrawableCondition} from "./Condition/NodeDrawableCondition";
+import {ParseNodeDrawable} from "../ParseNodeDrawable";
+
+export class NodeDrawableCollector {
+
+    private condition: NodeDrawableCondition
+    private rootNode: ParseNodeDrawable
+
+    constructor(rootNode: ParseNodeDrawable, condition: NodeDrawableCondition) {
+        this.rootNode = rootNode
+        this.condition = condition
+    }
+
+    private collectNodes(parseNode: ParseNodeDrawable, collected: Array<ParseNodeDrawable>){
+        if (this.condition == null || this.condition.satisfies(parseNode)){
+            collected.push(parseNode);
+        }
+        for (let i = 0; i < parseNode.numberOfChildren(); i++){
+            this.collectNodes(<ParseNodeDrawable>parseNode.getChild(i), collected);
+        }
+    }
+
+    collect(): Array<ParseNodeDrawable>{
+        let result = new Array<ParseNodeDrawable>();
+        this.collectNodes(this.rootNode, result);
+        return result;
+    }
+}

package/source/Processor/NodeModification/ConvertToLayeredFormat.ts

@@ -0,0 +1,16 @@
+import {NodeModifier} from "./NodeModifier";
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class ConvertToLayeredFormat implements NodeModifier{
+
+    modifier(parseNode: ParseNodeDrawable): void {
+        if (parseNode.isLeaf()){
+            let name = parseNode.getData().getName();
+            parseNode.clearLayers();
+            parseNode.getLayerInfo().setLayerData(ViewLayerType.ENGLISH_WORD, name);
+            parseNode.clearData();
+        }
+    }
+
+}

package/source/Processor/NodeModification/NodeModifier.ts

@@ -0,0 +1,6 @@
+import {ParseNodeDrawable} from "../../ParseNodeDrawable";
+
+export interface NodeModifier {
+
+    modifier(parseNode: ParseNodeDrawable): void
+}

package/source/Processor/TreeModifier.ts

@@ -0,0 +1,20 @@
+import {ParseTreeDrawable} from "../ParseTreeDrawable";
+import {NodeModifier} from "./NodeModification/NodeModifier";
+import {ParseNodeDrawable} from "../ParseNodeDrawable";
+
+export class TreeModifier{
+
+    private parseTree: ParseTreeDrawable
+    private nodeModifier: NodeModifier
+
+    private nodeModifyPrivate(parseNode: ParseNodeDrawable){
+        this.nodeModifier.modifier(parseNode);
+        for (let i = 0; i < parseNode.numberOfChildren(); i++){
+            this.nodeModifyPrivate(<ParseNodeDrawable> parseNode.getChild(i));
+        }
+    }
+
+    nodeModify(){
+        this.nodeModifyPrivate(<ParseNodeDrawable> this.parseTree.getRoot());
+    }
+}

package/source/Processor/TreeToStringConverter.ts

@@ -0,0 +1,31 @@
+import {LeafToStringConverter} from "./LeafConverter/LeafToStringConverter";
+import {ParseTreeDrawable} from "../ParseTreeDrawable";
+import {ParseNodeDrawable} from "../ParseNodeDrawable";
+
+export class TreeToStringConverter {
+
+    private converter: LeafToStringConverter
+    private parseTree: ParseTreeDrawable
+
+    constructor(parseTree: ParseTreeDrawable, converter: LeafToStringConverter) {
+        this.converter = converter
+        this.parseTree = parseTree
+    }
+
+    private convertToString(parseNode: ParseNodeDrawable): string{
+        if (parseNode.isLeaf()){
+            return this.converter.leafConverter(parseNode);
+        } else {
+            let st = "";
+            for (let i = 0; i < parseNode.numberOfChildren(); i++) {
+                st = st + this.convertToString(<ParseNodeDrawable> parseNode.getChild(i));
+            }
+            return st;
+        }
+    }
+
+    convert(){
+        return this.convertToString(<ParseNodeDrawable> this.parseTree.getRoot());
+    }
+
+}

package/source/TreeBankDrawable.ts

@@ -0,0 +1,47 @@
+import {TreeBank} from "nlptoolkit-parsetree/dist/TreeBank";
+import * as fs from "fs";
+import {ParseTreeDrawable} from "./ParseTreeDrawable";
+import {FileDescription} from "nlptoolkit-corpus/dist/FileDescription";
+import {ParseTree} from "nlptoolkit-parsetree/dist/ParseTree";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class TreeBankDrawable extends TreeBank{
+
+    constructor(folder?: string, pattern?: string) {
+        super();
+        let files = fs.readdirSync(folder);
+        files.sort()
+        for (let file of files){
+            if (pattern != undefined){
+                if (!file.includes(pattern)){
+                    continue
+                }
+            }
+            let parseTree = new ParseTreeDrawable(folder + "/" + file)
+            if (parseTree.getRoot() != undefined){
+                parseTree.setName(file);
+                this.parseTrees.push(parseTree);
+            }
+        }
+    }
+
+    getParseTrees(): Array<ParseTree>{
+        return this.parseTrees
+    }
+
+    get(index: number): ParseTreeDrawable{
+        return <ParseTreeDrawable> this.parseTrees[index];
+    }
+
+    clearLayer(layerType: ViewLayerType){
+        for (let tree of this.parseTrees){
+            let parseTree = <ParseTreeDrawable> tree;
+            parseTree.clearLayer(layerType);
+        }
+    }
+
+    removeTree(index: number){
+        this.parseTrees.slice(index, 1)
+    }
+
+}

package/source/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "outDir": "../dist",
+    "module": "umd",
+    "target": "es6",
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": false,
+    "removeComments": false,
+    "moduleResolution": "node",
+    "declaration": true
+  }
+}