def run(self):
parser = Parser()
while True:
sourceStr = raw_input("Enter an infix expression: ")
if sourceStr == "": break
try:
parser.parse(sourceStr)
print parser.parseStatus()
except Exception, e:
print "Error:"
print e
def run(self):
parser = Parser()
while True:
sourceStr = raw_input("Enter an infix expression: ")
if sourceStr == "": break
try:
parser.parse(sourceStr)
print parser.parseStatus()
except Exception, e:
print "Error:"
print e
def run(self):
parser = Parser()
while True:
sourceStr = input(
"Enter an arithmetic expression or just enter to quit: ")
if sourceStr == "": break
try:
parser.parse(sourceStr)
print(parser.parseStatus())
print(parser.tree)
except Exception as e:
print("Error:")
print(e)
def identifyCorpus(corpus, x=-1):
""" update corpus with mwedictionaries (type, count, tokens),
train, predict and evaluate corpus
"""
print(XPParams.use_extern_labels)
if XPParams.use_extern_labels:
Parser.parse(corpus, "") # -> prediction
scores = Evaluation.evaluate(corpus) # -> evaluate
else:
corpus.update()
clf = EmbeddingOracle.train(corpus, x) # -> training
Parser.parse(corpus, clf) # -> prediction
scores = Evaluation.evaluate(corpus) # -> evaluate
return scores
class Interpreter(object):
def __init__(self, w_m, profile):
self.parser = Parser()
self.profile = profile
self.w_m = w_m
self.k_b = KnowledgeBase()
def interpret(self, stimulus):
self.w_m.push_input()
parsed_data = self.parser.parse(stimulus)
classes = []
for wrd in parsed_data:
matched = self.k_b.match(wrd)
if matched:
classes.append(matched[0])
for cls in classes:
word_class = cls.get_word_class()
if word_class == 'noun':
self.w_m.percept.nouns.append(cls)
elif word_class == 'verb':
self.w_m.percept.verbs.append(cls)
elif word_class == 'adjective':
self.w_m.percept.adjectivs.append(cls)
elif word_class == 'adverb':
self.w_m.percept.adverbs.append(cls)
def test_pid(self):
p = Parser()
res = p.parse(self.f, None, False)
for pid, trace in res.iteritems():
for timestamp, data in trace.iteritems():
self.assertTrue(pid == data['pid'])
self.assertTrue(timestamp == data['timestamp'])
for item in ('path', 'timestamp', 'type'):
self.assertTrue(item in data)
def test_main(self):
p = Parser()
res = p.parse(self.f, None, False)
self.assertTrue(len(res) == 6)
for e in res:
self.assertTrue(isinstance(e, dict))
self.assertTrue(isinstance(e['path'], basestring))
self.assertTrue(isinstance(e['version'], basestring))
def run(self):
parser = Parser()
while True:
sourceStr = input("Enter an infix expression: ")
if sourceStr == "": break
try:
tree = parser.parse(sourceStr)
print("Prefix:", tree.prefix())
print("Infix:", tree.infix())
print("Postfix:", tree.postfix())
print("Value:", tree.value())
except Exception as e:
print("Error:")
print(e)
def test_parse(self):
for f in self.files:
p = Parser()
res = p.parse(f, None, False)
self.assertTrue(
isinstance(res, dict) or \
isinstance(res, list) or \
res is None)
res = p.parse(f, None, True)
self.assertTrue(isinstance(res, tuple))
self.assertTrue(len(res) == 2)
res = p.parse(f, None, False)
def_parser = PARSERS_CONFIG.get(p.ext, None)
cond = def_parser != None and res != {} or\
def_parser == None and res == {}
self.assertTrue(cond)
def run(self):
parser = Parser()
while True:
sourceStr = input("Enter an infix expression: ")
if sourceStr == "": break
try:
tree = parser.parse(sourceStr)
print("Prefix:", tree.prefix())
print("Infix:", tree.infix())
print("Postfix:", tree.postfix())
print("Value:", tree.value())
except Exception as e:
print("Error:")
print(e)
def test_main(self):
p = Parser()
res = p.parse(self.f, None, False)
self.assertTrue(len(res) == 9)
for grp, data in res.iteritems():
self.assertTrue(isinstance(data, list))
for symbol in data:
self.assertTrue(isinstance(symbol, dict))
self.assertTrue(isinstance(symbol['name'], basestring))
self.assertTrue(
isinstance(symbol['offset'], basestring) or \
isinstance(symbol['offset'], int))
def identifyCorpus(corpus):
corpus.update()
clf = EmbeddingOracle.train(corpus)
Parser.parse(corpus, clf)
scores = Evaluation.evaluate(corpus)
return scores
def test_main(self):
p = Parser()
res = p.parse(self.f, None, False)
self.assertTrue(len(res) == 9)
def test_trace(self):
p = Parser()
res = p.parse(self.f, None, False)
self.assertTrue(res['trace'] is not None)
self.assertTrue(len(res['trace']) == 268)
def test_summary(self):
p = Parser()
res = p.parse(self.f, None, False)
self.assertTrue(res['summary'] is not None)
self.assertTrue(len(res['summary']) == 46)
#!/usr/bin/env python
import sys
import json
from utils import *
from parsers import Parser
if __name__ == '__main__':
CIFP = open('CIFP/FAACIFP18', 'r')
Lines = CIFP.readlines()
parser = Parser()
parser.parse(Lines[23029:296000])
with open('CIFP_parsed/CIFP_parsed', 'w') as outfile:
json.dump(parser.CIFP_parsed, outfile, sort_keys=True, indent=4)
