def createTreeFromJson():
with open('result.json') as jsonData:
data = json.load(jsonData)
dependencyParse = data["result"]["paragraphs"][0]["sentences"][0][
"dependencyParse"]
tokens = data["result"]["paragraphs"][0]["sentences"][0]["tokens"]
nodeList = list()
root = Tree("root", "root")
for elem in tokens:
id = elem["id"]
val = elem["chosenInterpretation"]["base"]
ctag = elem["chosenInterpretation"]["ctag"]
nodeList.append(Tree(val, id, ctag))
for place, elem in enumerate(dependencyParse):
endTokenId = elem["endTokenId"]
startTokenId = elem["startTokenId"]
if startTokenId is None:
child = next(x for x in nodeList if x.id == endTokenId)
print(child)
root.addChild(child)
else:
parent = next(x for x in nodeList if x.id == startTokenId)
child = next(x for x in nodeList if x.id == endTokenId)
parent.addChild(child)
dependencyParse[place] = parent
return root, nodeList
def main():
tr = Tree("A")
tr.addChild("B")
tr.addChild("C")
tr.addChild("D")
children = tr.getChildren()
for i in range(len(children)):
children[i].addChild(i)
print_tree(tr)
def test_NewTree(self):
root = Tree("Root")
child1 = Tree("C01")
child2 = Tree("C02")
child21 = Tree("C21")
root.addChild(child1)
root.addChild(child2)
child2.addChild(child21)
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[0].data, "C01")
def test_NewTree(self):
root = Tree("Root")
child1 = Tree("C01")
child2 = Tree("C02")
child21 = Tree("C21")
root.addChild(child1)
root.addChild(child2)
child2.addChild(child21)
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[0].data, "C01")
def extract_threads_targets(self, features, tweetIds, infectedTweetIds, labels, makeTarget=True, return_full=False):
trees = [];
for ind, tweetId in enumerate(tweetIds):
infectedTweetId = infectedTweetIds[ind];
infectedTweet = None
for tree in trees:
infectedTweet = tree.find(infectedTweetId);
if infectedTweet is not None:
break;
if infectedTweet is None:
if makeTarget:
auxilary = (features[list(infectedTweetIds).index(infectedTweetId)],
[1 if i == labels[list(infectedTweetIds).index(infectedTweetId)] else 0 for i in xrange(4)])
else:
auxilary = (features[list(infectedTweetIds).index(infectedTweetId)], []);
infectedTweet = Tree(data=infectedTweetId, auxilaries=auxilary);
trees.append(infectedTweet)
if infectedTweetId != tweetId:
tweet = None;
for tree in trees:
tweet = tree.find(tweetId);
if tweet is not None:
break;
if tweet is not None:
infectedTweet.addChildNode(tweet)
else:
if makeTarget:
auxilary = (features[list(tweetIds).index(tweetId)],
[1 if i == labels[list(tweetIds).index(tweetId)] else 0 for i in
xrange(4)])
else:
auxilary = (features[list(tweetIds).index(tweetId)], []);
infectedTweet.addChild(tweetId, auxilaries=auxilary);
tweetTree = Tree();
for tree in trees:
root = tree.getRoot()
if root is tree:
tweetTree.addChildNode(root);
threads = tweetTree.extractThreads();
if makeTarget:
return map(lambda thread: [e.auxilaries[0] for e in thread], threads), map(
lambda thread: [e.auxilaries[1] for e in thread], threads);
else:
if return_full:
return threads;
else:
return map(lambda thread: [e.auxilaries[0] for e in thread], threads);
class TestTree(unittest.TestCase):
def setUp(self):
"""
Test Tree structure:
Root
|___ C01
| |___ C11
| |___ C111
| |___ C112
|___ C02
|___ C03
| |___ C31
"""
self.root = Tree('Root')
self.child01 = Tree('C01')
self.child02 = Tree('C02')
self.child03 = Tree('C03')
self.child11 = Tree('C11')
self.child31 = Tree('C31')
self.child111 = Tree('C111')
self.child112 = Tree('C112')
self.root.addChildren([self.child01, self.child02, self.child03])
self.child01.addChild(self.child11)
self.child03.addChild(self.child31)
self.child11.addChild(self.child111)
self.child11.addChild(self.child112)
#self.root.printTree(T)
def test_initialization(self):
pass
def test_NewTree(self):
root = Tree("Root")
child1 = Tree("C01")
child2 = Tree("C02")
child21 = Tree("C21")
root.addChild(child1)
root.addChild(child2)
child2.addChild(child21)
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[0].data, "C01")
def test_NewTreeSingle(self):
child1 = Tree("C01")
root = Tree('Root', child1)
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[0].data, "C01")
def test_NewTreeMulti(self):
child1 = Tree("C01")
child2 = Tree("C02")
root = Tree('Root', [child1, child2])
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[1].data, "C02")
def test_Parent(self):
self.assertEqual(self.child01.getParent(), self.root)
self.assertEqual(self.child02.getParent(), self.root)
self.assertEqual(self.child03.getParent(), self.root)
self.assertEqual(self.child11.getParent(), self.child01)
self.assertEqual(self.child31.getParent(), self.child03)
def test_IsRoot(self):
self.assertTrue(self.root.isRoot())
self.assertFalse(self.child01.isRoot())
self.assertFalse(self.child31.isRoot())
def test_IsBranch(self):
self.assertFalse(self.root.isBranch())
self.assertFalse(self.child01.isBranch())
self.assertFalse(self.child03.isBranch())
self.assertTrue(self.child02.isBranch())
self.assertFalse(self.child11.isBranch())
self.assertTrue(self.child31.isBranch())
def test_ChildrendotAssign(self):
#self.root.children = []
with self.assertRaises(AttributeError) as excpt:
self.root.children = []
self.assertEqual(excpt.expection, AttributeError)
def test_GetRoot(self):
self.assertEqual(self.root.getRoot(), self.root);
self.assertEqual(self.child01.getRoot(), self.root)
self.assertEqual(self.child31.getRoot(), self.root)
def test_GetChild(self):
self.assertEqual(self.root.getChild(2), self.child03)
self.assertEqual(self.child03.getChild(0), self.child31);
def test_GetNode(self):
self.assertEqual(self.root.getNode('C31'), self.child31)
self.assertEqual(self.child11.getNode('C11'), self.child11)
self.assertEqual(self.root.getNode('C41'), None)
def test_DelChild(self):
self.child11.delChild(0);
self.root.printTree(T)
def test_DelNode(self):
self.root.delNode('C03');
self.root.printTree(T)
def test_PrintTree(self):
self.root.printTree(S)
self.root.printTree(T)
#[Root[C01[C11[C111,C112]],C02,C03[C31]]]
def tearDown(self):
del self.root
class TestTree(unittest.TestCase):
def setUp(self):
"""
Test Tree structure:
Root
|___ C01
| |___ C11
| |___ C111
| |___ C112
|___ C02
|___ C03
| |___ C31
"""
self.root = Tree('Root')
self.child01 = Tree('C01')
self.child02 = Tree('C02')
self.child03 = Tree('C03')
self.child11 = Tree('C11')
self.child31 = Tree('C31')
self.child111 = Tree('C111')
self.child112 = Tree('C112')
self.root.addChildren([self.child01, self.child02, self.child03])
self.child01.addChild(self.child11)
self.child03.addChild(self.child31)
self.child11.addChild(self.child111)
self.child11.addChild(self.child112)
#self.root.printTree(T)
def test_initialization(self):
pass
def test_NewTree(self):
root = Tree("Root")
child1 = Tree("C01")
child2 = Tree("C02")
child21 = Tree("C21")
root.addChild(child1)
root.addChild(child2)
child2.addChild(child21)
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[0].data, "C01")
def test_NewTreeSingle(self):
child1 = Tree("C01")
root = Tree('Root', child1)
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[0].data, "C01")
def test_NewTreeMulti(self):
child1 = Tree("C01")
child2 = Tree("C02")
root = Tree('Root', [child1, child2])
self.assertEqual(root.data, "Root")
self.assertEqual(root.getChildren()[1].data, "C02")
def test_Parent(self):
self.assertEqual(self.child01.getParent(), self.root)
self.assertEqual(self.child02.getParent(), self.root)
self.assertEqual(self.child03.getParent(), self.root)
self.assertEqual(self.child11.getParent(), self.child01)
self.assertEqual(self.child31.getParent(), self.child03)
def test_IsRoot(self):
self.assertTrue(self.root.isRoot())
self.assertFalse(self.child01.isRoot())
self.assertFalse(self.child31.isRoot())
def test_IsBranch(self):
self.assertFalse(self.root.isBranch())
self.assertFalse(self.child01.isBranch())
self.assertFalse(self.child03.isBranch())
self.assertTrue(self.child02.isBranch())
self.assertFalse(self.child11.isBranch())
self.assertTrue(self.child31.isBranch())
def test_ChildrendotAssign(self):
#self.root.children = []
with self.assertRaises(AttributeError) as excpt:
self.root.children = []
self.assertEqual(excpt.expection, AttributeError)
def test_GetRoot(self):
self.assertEqual(self.root.getRoot(), self.root)
self.assertEqual(self.child01.getRoot(), self.root)
self.assertEqual(self.child31.getRoot(), self.root)
def test_GetChild(self):
self.assertEqual(self.root.getChild(2), self.child03)
self.assertEqual(self.child03.getChild(0), self.child31)
def test_GetNode(self):
self.assertEqual(self.root.getNode('C31'), self.child31)
self.assertEqual(self.child11.getNode('C11'), self.child11)
self.assertEqual(self.root.getNode('C41'), None)
def test_DelChild(self):
self.child11.delChild(0)
self.root.printTree(T)
def test_DelNode(self):
self.root.delNode('C03')
self.root.printTree(T)
def test_PrintTree(self):
self.root.printTree(S)
self.root.printTree(T)
#[Root[C01[C11[C111,C112]],C02,C03[C31]]]
def tearDown(self):
del self.root
class SubstituteTree(EvaluateTree):
def __init__(self, expression, domain, proposal):
EvaluateTree.__init__(self, proposal)
for variable in expression.variables():
self.addChild(ProposeTree(expression.substitute({variable.name(): proposal}), domain))
class Evaluator:
def value(self, expression):
return expression.value()
if __name__ == '__main__':
from Tree import Tree
assert EvaluateTree.createWith(Minus(Variable('A'),Variable('B')), [0, 1, 2]) != None
root = Tree(Variable('A'))
root.addChild(Tree(0).addChild(Tree(Number(0))))
assert EvaluateTree.createWith(Variable('A'), [0]) == root
root = Tree(Variable('A'))
root.addChild(Tree(0).addChild(Tree(Number(0))))
root.addChild(Tree(1).addChild(Tree(Number(1))))
assert EvaluateTree.createWith(Variable('A'), [0,1]) == root
evaluator = Evaluator()
assert EvaluateTree.createWith(Minus(Variable('A'), Variable('B')), [0]).alphaBeta(evaluator) == 0
assert EvaluateTree.createWith(Minus(Variable('A'), Variable('B')), [0, 1]).alphaBeta(evaluator) == 0
assert EvaluateTree.createWith(Minus(Variable('A'), Variable('B')), [0, 1, 2]).alphaBeta(evaluator) == 1
assert EvaluateTree.createWith(Minus(Variable('A'), Variable('B')), [0, 1, 2, 3]).alphaBeta(evaluator) == 1
assert EvaluateTree.createWith(Minus(Variable('A'), Variable('B')), [0, 1, 2, 3, 4]).alphaBeta(evaluator) == 2
