mainKatum=lexicalUnit.find(lUName)
if mainKatum!=None:
if(mainKatum.countI!=0):
for lU in mainKatum.I0:
lUID=id_.of(lU)
if(lUID.O==fnLexicalUnit.ID):
return lU
return None
def exactFrame(fnFrame):
frameKatum=frames.find(fnFrame.name)
if frameKatum!=None:
return frameKatum
return None
katum.load('wordnet-verbnet-framenet-semTypes.datum', atum())
generalThing = datum.thing
framenetRoot=generalThing.find("framenet")
frameElement=framenetRoot.find("frame element")
lexicalUnit=framenetRoot.find("lexical unit")
semType=framenetRoot.find("semantic type")
id_=framenetRoot.find("id")
frames=framenetRoot.find("frame")
for fE in fn.fes():
if fE.semType!=None:
semanticTypeKatum=exactSemType(fE.semType)
frameElementkatum=exactFE(fE)
if(semanticTypeKatum!=None and frameElementkatum!=None):
frameElementkatum._is(semanticTypeKatum,False)
if (wordInDatum.countI > 0):
for instance in wordInDatum.I:
defin = definition.of(instance)
if (defin != None):
if (defin.O == currentDefinition):
return instance
return None
def getName(wne):
x = wne.name()
x = str(x)
return x
katum.load('wordnet-hyponyms-exceptions-topicdomains.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordRoot = wordnetRoot.find("wordroot")
lemma_ = wordnetRoot.get("lemma")
for word in wordRoot.I:
wordItself = word.O
listOfSynsets = wn.synsets(wordItself)
for synset in listOfSynsets:
listOfLemmas = synset.lemma_names()
if (len(listOfLemmas) > 1):
exactInstance = getExactSynset(synset, word, wordnetRoot)
if (exactInstance != None):
for lemma in listOfLemmas:
apple.set(weight.Get(1.0))
mango.set(color.Get('green'), weight.Get(0.9))
banana.set(color.Get('yellow'), weight.Get(1.1))
fruit.set(weight.Get(AvgFunc)) # <---
assert Of(weight, fruit) == 1 # average of 1, .9, 1.1
############################
# Tutorial 2
# 7 Query
# 7.1 Setup for Northwind
katum.load('northwind.datum', atum())
northwindDB = datum.thing
assert northwindDB is not None
Table = northwindDB.find("Table")
assert Table is not None
Column = northwindDB.find("Column")
assert Column is not None
Employee = Table.find("Employee")
assert Employee is not None
Order = Table.find("Order")
assert Order is not None
Customer = Table.find("Customer")
assert Customer is not None
def getExactKatum(synset):
name = synset.name()
word = name.split('.')[0]
wordKatum = wordRoot.find(word)
if (wordKatum != None):
synsetDefinition = synset.definition()
for instance in wordKatum.I:
instanceDefinition = definition.of(instance)
if (instanceDefinition != None
and instanceDefinition.O == synsetDefinition):
return instance
return None
katum.load('wordnet-notopicdomains.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordRoot = wordnetRoot.find("wordroot")
definition = wordnetRoot.find("definition")
topicDomain_ = wordnetRoot.get("topic domain")
count = 1
for word in wordRoot.I:
if (word.countI > 0):
for instance in word.I:
exactSynset = getExactSynset(instance)
if exactSynset:
topicDomains = exactSynset.topic_domains()
if len(topicDomains) > 0:
for topicDomain in topicDomains:
topicDomainKatum = getExactKatum(topicDomain)
def addAntonyms(synset):
doneAntonyms[synset] = True
exactSynset = getExactKatum(synset)
if exactSynset != None:
anotnymKatum = antonym.Get(antonym.countI)
anotnymKatum._is(symmetrical, False)
exactSynset._is(anotnymKatum, False)
for anotnym_ in synset.lemmas()[0].antonyms():
anotnymSynset = getExactKatum(anotnym_.synset())
if anotnymSynset != None:
anotnymSynset._is(anotnymKatum, False)
doneAntonyms[anotnym_.synset()] = True
katum.load('wordnetonlysynsets.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordRoot = wordnetRoot.find("wordRoot")
definition = wordnetRoot.find("definition")
exception = wordnetRoot.Get("exception")
relation = wordnetRoot.Get("relation")
symmetrical = wordnetRoot.Get("symmetrical")
antonym = relation.Get("antonym")
for synset in list(wn.all_synsets()):
name = synset.name()
type_ = name.split('.')[1]
if (type_ == 's' or type_ == 'a' or type_ == 'r' or type_ == 'v'
or type_ == 'n'):
if synset.hyponyms() != None:
if (len(vn.wordnetids(classID)) > 0):
for wordnetInstance in vn.wordnetids(classID):
synset = synsetFromSenseKey(wordnetInstance + helper)
if (synset != None):
wordKatum = exactKatumFromSynset(wn.synset(synset),
wordnetRoot)
if (wordKatum != None):
wordKatum._is(numVerbKatum, False)
print done, wordKatum.a0.O, wordKatum.O, numVerbKatum.a0.O, numVerbKatum.O
done += 1
classToKatumDict[classID] = numVerbKatum
processClass(numVerbKatum, classID)
processThemRoles(numVerbKatum, classID)
katum.load('wordnet.datum', atum())
generalThing = datum.thing
verbnetRoot = generalThing.get("verbnet")
wordnetRoot = generalThing.find("wordnet")
class_ = verbnetRoot.get("class")
verbclassID = verbnetRoot.get("verb class id")
verbroot = verbnetRoot.get("verbroot")
example = verbnetRoot.get("example")
semantics = verbnetRoot.get("semantics")
syntax = verbnetRoot.get("syntax")
verbclass_ = verbnetRoot.get("verb class")
description = verbnetRoot.get("description")
semanticsArguments = verbnetRoot.get("semantics argument")
syntaxArguments = verbnetRoot.get("syntax argument")
syntaxFramesKatum = verbnetRoot.get("syntactic argument")
semanticsFramesKatum = verbnetRoot.get("semantics predicate")
from collections import deque
os.chdir(os.getcwd())
from cpyDatumTron import atum, datum, katum, Of, Intersect, Union
def exactFrame(frame):
mainFE=frameElement.find(frame.name)
if mainFE!=None:
for mainFEinst in mainFE.I:
mainFEinstID=id_.of(mainFEinst)
if mainFEinstID.O == frame.ID:
return mainFEinst
return None
katum.load('wordnet-verbnet-framenet-fr.datum', atum())
generalThing = datum.thing
framenetRoot=generalThing.find("framenet")
frameElement=framenetRoot.find("frame element")
id_=framenetRoot.find("id")
relation=framenetRoot.get("relation")
requires=relation.get("requires frame element")
excludes=relation.get("excludes frame element")
for fe in fn.fes():
if(fe.excludesFE!=None):
mainFE=exactFrame(fe)
excludedFE=exactFrame(fe.excludesFE)
if(mainFE!=None and excludedFE!=None):
excludeskatum=excludes.get(excludes.countI)
mainFE._is(excludeskatum,False)
excludedFE._is(excludeskatum,False)
if(type_!="notfound"):
if(wordInDatum.countI>0):
for instance in wordInDatum.I:
if(instance.Is(wnr.find(type_))):
defin=definition.of(instance)
if(defin!=None):
if(defin.O==currentDefinition):
return instance
return None
def getName(wne):
x=wne.name()
x=str(x)
return x
katum.load('wordnet-nosister.datum', atum())
generalThing = datum.thing
wordnetRoot=generalThing.find("wordnet")
wordRoot=wordnetRoot.find("wordRoot")
has=wordnetRoot.find("has")
sister=wordnetRoot.get("sister")
for word in wordRoot.I:
wordItself=word.O
listOfSynsets=wn.synsets(wordItself)
for synset in listOfSynsets:
if not visited.get(synset.name(),False):
visited[synset.name()]=True
exactInstance=getExactSynset(synset,word,wordnetRoot)
if(exactInstance!=None):
import nltk
from nltk.corpus import wordnet as wn
import re
import os
from collections import deque
os.chdir(os.getcwd())
from cpyDatumTron import atum, datum, katum, Of, Intersect, Union
visited = set()
katum.load('wordnet-noverbgroups.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordroot = wordnetRoot.find("wordroot")
verbGroup = wordnetRoot.get("verb group")
def getExactSynset(syn):
word = str(syn.name()).split('.')[0]
wordInDatum = wordroot.find(word)
if wordInDatum != None:
definition = wordnetRoot.find("definition")
currentDefinition = syn.definition()
priority = wordnetRoot.find("priority")
pos = syn.pos()
type_ = "notfound"
if (pos == 'n'):
type_ = "noun"
elif (pos == 'v'):
type_ = "verb"
type_="adjective satellite"
if(type_!="notfound"):
if(wordInDatum.countI>0):
for instance in wordInDatum.I:
defin=definition.of(instance)
if(defin!=None):
if(defin.O==currentDefinition):
return instance
return None
def getName(wne):
x=wne.name()
x=str(x)
return x
katum.load('wordnet-nolemmas.datum', atum())
generalThing = datum.thing
wordnetRoot=generalThing.find("wordnet")
wordRoot=wordnetRoot.find("wordroot")
lemma_=wordnetRoot.get("lemma")
for word in wordRoot.I:
wordItself=word.O
listOfSynsets=wn.synsets(wordItself)
for synset in listOfSynsets:
listOfLemmas=synset.lemma_names()
if(len(listOfLemmas)>1):
exactInstance=getExactSynset(synset,word,wordnetRoot)
if(exactInstance!=None):
for lemma in listOfLemmas:
def getExactKatum(synset):
name = synset.name()
word = name.split('.')[0]
wordKatum = wordRoot.find(word)
if (wordKatum != None):
synsetDefinition = synset.definition()
for instance in wordKatum.I:
instanceDefinition = definition.of(instance)
if (instanceDefinition != None
and instanceDefinition.O == synsetDefinition):
return instance
return None
katum.load('wordnet-noregiondomains.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordRoot = wordnetRoot.find("wordroot")
definition = wordnetRoot.find("definition")
regionDomain_ = wordnetRoot.get("region domain")
count = 1
for word in wordRoot.I:
if (word.countI > 0):
for instance in word.I:
exactSynset = getExactSynset(instance)
if exactSynset:
regionDomains = exactSynset.region_domains()
if len(regionDomains) > 0:
for regionDomain in regionDomains:
regionDomainKatum = getExactKatum(regionDomain)
for meronym in listOfMeronyms:
if not visited.get(meronym,False):
visited[meronym]=True
meronymWordnet=wordroot.find(meronym.name().split('.')[0])
if(meronymWordnet!=None):
exactMeronym=getExactSynset(meronym,meronymWordnet,wordnetRoot)
if(exactMeronym!=None):
meronymName=exactMeronym.a0.O
meronymNumber=exactMeronym.countI+1
newMeronymInstance=parent.get(meronymName+str(meronymNumber))
newMeronymInstance._is(exactMeronym)
addHas(meronym,meronymWordnet,wordnetRoot,newMeronymInstance)
katum.load('wordnet-nohas.datum', atum())
generalThing = datum.thing
wordnetRoot=generalThing.find("wordnet")
wordroot=wordnetRoot.find("wordroot")
has=wordnetRoot.get("has")
for w in wordroot.I:
wordItself=w.O
listOfSynsets=wn.synsets(wordItself)
for synset in listOfSynsets:
if (len(synset.part_meronyms()) > 0 and len(synset.part_holonyms())==0):
if not visited.get(synset,False):
visited[synset]=True
exactInstance=getExactSynset(synset,w,wordnetRoot)
if(exactInstance!=None):
import nltk
from nltk.corpus import wordnet as wn
import re
import os
from collections import deque
os.chdir(os.getcwd())
from cpyDatumTron import atum, datum, katum, Of, Intersect, Union
visited = set()
katum.load('wordnet-norelatedform.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordroot = wordnetRoot.find("wordroot")
relatedForm = wordnetRoot.get("derivationally related form")
def getExactSynset(syn):
word = str(syn.name()).split('.')[0]
wordInDatum = wordroot.find(word)
if wordInDatum != None:
definition = wordnetRoot.find("definition")
currentDefinition = syn.definition()
priority = wordnetRoot.find("priority")
pos = syn.pos()
type_ = "notfound"
if (pos == 'n'):
type_ = "noun"
elif (pos == 'v'):
type_ = "verb"
elif (pos == 'r'):
from collections import deque
os.chdir(os.getcwd())
from cpyDatumTron import atum, datum, katum, Of, Intersect, Union
def addframeRelations(frame):
for frameRelation in frame.frameRelations:
if 'Parent' in frameRelation:
parentKatum=frame_.get(frameRelation.Parent.name)
childKatum=frame_.get(frameRelation.Child.name)
childKatum._is(frameRelations,False)
childKatum._is(parentKatum,False)
parentKatum._is(frameRelations,False)
katum.load('wordnet-verbnet-framenet-noframerelations.datum', atum())
generalThing = datum.thing
framenetRoot=generalThing.find("framenet")
frame_=framenetRoot.find("frame")
for frame in frame_.I:
framenetFrame=fn.frame(frame.O)
for frameRelation in framenetFrame.frameRelations:
if 'Parent' in frameRelation:
parentKatum=frame_.find(frameRelation.Parent.name)
if 'Child' in frameRelation:
childKatum=frame_.find(frameRelation.Child.name)
if(parentKatum!=None and childKatum!=None):
childKatum._is(parentKatum,False)
def getExactKatum(synset):
name = synset.name()
word = name.split('.')[0]
wordKatum = wordRoot.find(word)
if (wordKatum != None):
synsetDefinition = synset.definition()
for instance in wordKatum.I:
instanceDefinition = definition.of(instance)
if (instanceDefinition != None
and instanceDefinition.O == synsetDefinition):
return instance
return None
katum.load('wordnet-nousagedomains.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordRoot = wordnetRoot.find("wordroot")
definition = wordnetRoot.find("definition")
usageDomain_ = wordnetRoot.get("usage domain")
count = 1
for word in wordRoot.I:
if (word.countI > 0):
for instance in word.I:
exactSynset = getExactSynset(instance)
if exactSynset:
usageDomains = exactSynset.usage_domains()
if len(usageDomains) > 0:
for usageDomain in usageDomains:
usageDomainKatum = getExactKatum(usageDomain)
if (len(vn.wordnetids(classID)) > 0):
for wordnetInstance in vn.wordnetids(classID):
synset = synsetFromSenseKey(wordnetInstance + helper)
if (synset != None):
wordKatum = exactKatumFromSynset(wn.synset(synset),
wordnetRoot)
if (wordKatum != None):
wordKatum._is(numVerbKatum, False)
print done, wordKatum.a0.O, wordKatum.O, numVerbKatum.a0.O, numVerbKatum.O
done += 1
classToKatumDict[classID] = numVerbKatum
processClass(numVerbKatum, classID)
processThemRoles(numVerbKatum, classID)
katum.load('wordnet-example-definition.datum', atum())
generalThing = datum.thing
verbnetRoot = generalThing.get("verbnet")
wordnetRoot = generalThing.find("wordnet")
class_ = verbnetRoot.get("class")
verbclassID = verbnetRoot.get("verb class id")
verbroot = verbnetRoot.get("verbroot")
example = verbnetRoot.get("example")
semantics = verbnetRoot.get("semantics")
syntax = verbnetRoot.get("syntax")
verbclass_ = verbnetRoot.get("verb class")
description = verbnetRoot.get("description")
semanticsArguments = verbnetRoot.get("semantics argument")
syntaxArguments = verbnetRoot.get("syntax argument")
syntaxFramesKatum = verbnetRoot.get("syntactic argument")
semanticsFramesKatum = verbnetRoot.get("semantics predicate")
return synset
return None
def getExactKatum(synset):
name=synset.name()
word=name.split('.')[0]
wordKatum=wordRoot.find(word)
if(wordKatum!=None):
synsetDefinition=synset.definition()
for instance in wordKatum.I:
instanceDefinition=definition.of(instance)
if(instanceDefinition!=None and instanceDefinition.O==synsetDefinition):
return instance
return None
katum.load('wordnet-hyponyms-exceptions.datum', atum())
generalThing = datum.thing
wordnetRoot=generalThing.find("wordnet")
wordRoot=wordnetRoot.find("wordRoot")
definition=wordnetRoot.find("definition")
topicDomain_=wordnetRoot.get("topic domain")
for word in wordRoot.I:
if(word.countI>0):
for instance in word.I:
exactSynset=getExactSynset(instance)
if exactSynset:
topicDomains=exactSynset.topic_domains()
if len(topicDomains)>0:
for topicDomain in topicDomains:
topicDomainKatum=getExactKatum(topicDomain)
if topicDomainKatum:
from nltk.corpus import wordnet as wn
import os
os.chdir(os.getcwd())
from cpyDatumTron import atum, datum, katum, Of, Intersect, Union
visited = {}
katum.load('wordnet-nopertainym.datum', atum())
generalThing = datum.thing
wordnetRoot = generalThing.find("wordnet")
wordroot = wordnetRoot.find("wordroot")
pertainymRoot = wordnetRoot.get("pertainym")
def getExactSynset(syn, wordInDatum, wnr):
wordStr = getName(syn)
definition = wnr.find("definition")
currentDefinition = syn.definition()
priority = wnr.find("priority")
word = wordStr.split('.')[0]
pos = wordStr.split('.')[1]
type_ = "notfound"
if (pos == 'n'):
type_ = "noun"
elif (pos == 'v'):
type_ = "verb"
elif (pos == 'r'):
type_ = "adverb"
elif (pos == 'a'):
type_ = "adjective"
elif (pos == 's'):
