def output_text(request):
if request.method == 'GET':
name = request.GET.get('q')
tool = grammar_check.LanguageTool('en-GB')
texts = name
matches = tool.check(texts)
name = grammar_check.correct(texts, matches)
return render(request, 'index2.html', {'result': name})
def grammer_chek(sen):
matches = tool.check(sen)
if matches:
print(sen, "Syntax_error")
print("grammatic suggestion")
print(grammar_check.correct(sen, matches))
else:
print(sen, "No_syntax_error")
def interactive_decode():
with tf.Session() as sess:
# Create model and load parameters.
model = create_model(sess, True)
model.batch_size = 1 # We decode one sentence at a time.
# Load vocabularies.
en_vocab_path = os.path.join(FLAGS.data_dir, "vocab8000.from")
fr_vocab_path = os.path.join(FLAGS.data_dir, "vocab8000.to")
en_vocab, _ = data_utils.initialize_vocabulary(en_vocab_path)
_, rev_fr_vocab = data_utils.initialize_vocabulary(fr_vocab_path)
# Decode from standard input.
sys.stdout.write("> ")
sys.stdout.flush()
sentence = sys.stdin.readline()
while sentence:
# Get token-ids for the input sentence.
token_ids = data_utils.sentence_to_token_ids(
tf.compat.as_bytes(sentence), en_vocab)
# Which bucket does it belong to?
bucket_id = len(_buckets) - 1
for i, bucket in enumerate(_buckets):
if bucket[0] >= len(token_ids):
bucket_id = i
break
# else:
# logging.warning("Sentence truncated: %s", sentence)
# Get a 1-element batch to feed the sentence to the model.
encoder_inputs, decoder_inputs, target_weights = model.get_batch(
{bucket_id: [(token_ids, [])]}, bucket_id)
# Get output logits for the sentence.
_, _, output_logits = model.step(sess, encoder_inputs,
decoder_inputs, target_weights,
bucket_id, True)
# This is a greedy decoder - outputs are just argmaxes of output_logits.
outputs = [
int(np.argmax(logit, axis=1)) for logit in output_logits
]
# If there is an EOS symbol in outputs, cut them at that point.
if data_utils.EOS_ID in outputs:
outputs[:] = (value for value in outputs
if value != data_utils.EOS_ID)
# Print out French sentence corresponding to outputs.
text = " ".join(
[tf.compat.as_str(rev_fr_vocab[output]) for output in outputs])
matches = tool.check(text)
if len(matches):
print("original: " + text)
text = grammar_check.correct(text, matches)
print("corrected: " + text)
print(text)
print("> ", end="")
sys.stdout.flush()
sentence = sys.stdin.readline()
def check_sentence(cont, sentence):
'''
'''
try:
# Automatically apply suggestions to the text.
matches = tool.check(sentence)
suggestions = grammar_check.correct(sentence, matches)
print cont, sentence
if sentence != suggestions:
logging.info('Sentence: {}'.format(sentence))
logging.info('Suggestion: {} \n'.format(suggestions))
except Exception as err:
print err
def grammarCheckFile(filePath, checkpt):
for filename in glob.glob(os.path.join(filePath, 'dialogue_a_' + checkpt)):
newFileName = filename.replace(filePath +"/", "corrected_")
newFile = open(filePath +"/" + newFileName, 'w')
oldFile = open(filename, 'r')
dialogues = oldFile.readlines()
for i,line in enumerate(dialogues):
if i % 2 == 0:
newFile.write(line)
else:
line = line.encode('ascii', 'ignore')
matches = tool.check(line)
if len(matches):
line = grammar_check.correct(line, matches)
newFile.write(line)
newFile.close()
def decode(user_input, model, en_vocab, rev_fr_vocab, sess):
# Decode from standard input.
sys.stdout.write("> ")
sys.stdout.flush()
sentence = user_input
# Get token-ids for the input sentence.
token_ids = data_utils.sentence_to_token_ids(tf.compat.as_bytes(sentence),
en_vocab)
# Which bucket does it belong to?
bucket_id = len(_buckets) - 1
for i, bucket in enumerate(_buckets):
if bucket[0] >= len(token_ids):
bucket_id = i
break
else:
logging.warning("Sentence truncated: %s", sentence)
# Get a 1-element batch to feed the sentence to the model.
encoder_inputs, decoder_inputs, target_weights = model.get_batch(
{bucket_id: [(token_ids, [])]}, bucket_id)
# Get output logits for the sentence.
_, _, output_logits = model.step(sess, encoder_inputs, decoder_inputs,
target_weights, bucket_id, True)
# This is a greedy decoder - outputs are just argmaxes of output_logits.
outputs = [int(np.argmax(logit, axis=1)) for logit in output_logits]
# If there is an EOS symbol in outputs, cut them at that point.
if data_utils.EOS_ID in outputs:
outputs = outputs[:outputs.index(data_utils.EOS_ID)]
# Print out corresponding outputs.
output = " ".join(
[tf.compat.as_str(rev_fr_vocab[output]) for output in outputs])
matches = tool.check(text)
if len(matches):
print("original: " + output)
output = grammar_check.correct(output, matches)
print("corrected: " + output)
print(output)
return output
def main():
plotto = Plotto()
plotto.generate()
tool = grammar_check.LanguageTool('en-US')
masterplot = plotto.masterplot.getPlot()
plot_checked = grammar_check.correct(masterplot, tool.check(masterplot))
print capitalize(plot_checked.lower()) + '\n'
conflict = plotto.conflicts.getConflict()
characters = plotto.characters.getCharacters()
print conflict + '\n'
print 'Characters: '
for char in characters:
print char.name + ", " + char.role
print '\n'
def handlePost(request):
content = request.get_json(silent=True)
print content
if content.has_key('inputText'):
# Do basic grammar correction.
input_text = replaceContractions(content['inputText'])
matches = tool.check(input_text)
input_text = grammar_check.correct(input_text, matches)
passive_sentences = classifySentences(input_text)
alchemy_response = alchemyapi.keywords('text', input_text, {'sentiment': 1})
keywords = alchemy_response['keywords']
transformKeywords(keywords)
return memeSwitch(input_text)
# return jsonify(
# text=input_text,
# passive=passive_sentences
# )
else:
return 'ERROR: Couldn\'t find a text key.'
def handlePost(request):
content = request.get_json(silent=True)
print content
if content.has_key('inputText'):
# Do basic grammar correction.
input_text = replaceContractions(content['inputText'])
matches = tool.check(input_text)
input_text = grammar_check.correct(input_text, matches)
passive_sentences = classifySentences(input_text)
alchemy_response = alchemyapi.keywords('text', input_text,
{'sentiment': 1})
keywords = alchemy_response['keywords']
transformKeywords(keywords)
return memeSwitch(input_text)
# return jsonify(
# text=input_text,
# passive=passive_sentences
# )
else:
return 'ERROR: Couldn\'t find a text key.'
def main():
plotto = Plotto()
while (plotto.isPlotting()):
plotto.menu()
plotto.display()
plotto.generate()
tool = grammar_check.LanguageTool('en-US')
masterplot = plotto.masterplot.getPlot()
plot_checked = grammar_check.correct(masterplot, tool.check(masterplot))
print capitalize(plot_checked.lower()) + '\n'
conflict = plotto.conflicts.getConflict()
characters = plotto.characters.getCharacters()
print conflict + '\n'
print 'Characters: '
for char in characters:
print char.name + ", " + char.role
print '\n'
else:
self.cache[key] = [w3]
def generate_markov_text(self, size=10):
seed = random.randint(0, self.word_size-3)
seed_word, next_word = self.words[seed], self.words[seed+1]
w1, w2 = seed_word, next_word
gen_words = []
for i in xrange(size):
gen_words.append(w1)
w1, w2 = w2, random.choice(self.cache[(w1, w2)])
gen_words.append(w2)
return ' '.join(gen_words)
fname = open('movielines20000_raw.txt')
markov = Markov(fname)
tool = grammar_check.LanguageTool('en-GB')
start_time = time.time()
for i in range(10):
text = markov.generate_markov_text()
print time.time()-start_time
matches = tool.check(text)
print time.time()-start_time
print text
print time.time()-start_time
print grammar_check.correct(text, matches)
print time.time()-start_time
def generate_response(self, sentence, object_name, detail_name, question,
p_score, f_score, u_score, s_score, detail_array):
response = ""
object_score = 0
detail_score = 0
statement_score = 0
question_score = 0
self.question = question
pronoun_pool = []
noun_pool = []
adjectives_pool = []
connector_pool = []
verb_pool = []
past_verb_pool = []
simple_verb_pool = []
VRB_pool = []
rb_pool = []
MD_pool = []
WRB_pool = []
WP_pool = []
#multi-dimensional array
word_bank = []
if self.find_object_node(object_name):
print("Previous object found!")
object_score += 1
for entry in self.justTAG(sentence):
pos = entry[0]
tag = entry[1]
if tag == 'NN': #NOUNS
noun_pool.append(pos)
continue
elif tag == 'NNS': #NOUNS PLURAL
noun_pool.append(pos)
continue
elif tag == 'NNP': #unidentified pronoun
pronoun_pool.append(pos)
continue
elif tag == 'JJ': #ADJECTIVES
adjectives_pool.append(pos)
continue
elif tag == 'VBP': #VERB
verb_pool.append(pos)
continue
elif tag == 'VRB':
if pos == "do" and question:
WP_pool.append(pos)
else:
VRB_pool.append(pos)
continue
elif tag == 'VB':
simple_verb_pool.append(pos)
continue
elif tag == 'VBD':
past_verb_pool.append(pos)
continue
elif tag == 'VBG':
verb_pool.append(pos)
continue
elif tag == 'VBZ':
verb_pool.append(pos)
continue
elif tag == 'RB': #Example : do you STILL like me ?
rb_pool.append(pos)
continue
elif tag == 'MD':
MD_pool.append(pos)
continue
elif tag == 'WRB':
WRB_pool.append(pos)
continue
elif tag == 'WP':
WP_pool.append(pos)
continue
else:
continue
print("PRONOUNS " + str(pronoun_pool))
print("NOUNS " + str(noun_pool))
print("ADJECTIVES " + str(adjectives_pool))
print("VERBS " + str(verb_pool))
print("SIMPLE VERBS" + str(simple_verb_pool))
print("PAST VERBS " + str(past_verb_pool))
print("RB " + str(rb_pool))
print("VRB " + str(VRB_pool))
print("WRB " + str(WRB_pool))
print("MD" + str(MD_pool))
print("WP " + str(WP_pool))
existing_objects = dict()
detail_count = 0
line_num = 0
detail_array = []
noun_scores = dict()
self.global_noun_pool = noun_pool
for word in pronoun_pool:
if self.find_object_node(word):
total_score = 2
detail_count, line_num, detail_array = self.check_object_details(
self.get_object_line(word))
existing_objects[word] = detail_count
if word == object_name:
total_score = total_score * 3
total_score = total_score * detail_count
noun_scores[word] = total_score
else:
continue
for word in noun_pool:
print('word:' + word)
if self.find_object_node(word):
total_score = 2
detail_count, line_num, detail_array = self.check_object_details(
self.get_object_line(word))
existing_objects[word] = detail_count
if word == object_name:
total_score = total_score * 3
total_score = total_score * detail_count
noun_scores[word] = total_score
print("Existing objects" + str(existing_objects))
local_memory = self.get_local_memory(noun_pool)
server_memory = self.get_server_memory()
total_memory = self.get_total_memory(local_memory, server_memory)
print('LOCAL MEMORY = ' + str(local_memory))
print('SERVER MEMORY = ' + str(server_memory))
print('TOTAL MEMORY = ' + str(total_memory))
generated_word_bank = self.create_word_bank(total_memory)
print('WORD BANK : ' + str(generated_word_bank))
if question:
#get all segments from wrb,md, wp
banana_split = sentence.split(" ")
i = len(banana_split)
banana_max = 0
target_question = ""
for word in banana_split:
if word in WRB_pool or word in MD_pool or word in WP_pool:
banana_max = i
target_question = word
break
print("TARGET QUESTION : " + target_question)
local_memory = self.get_local_memory(noun_pool)
print('LOCAL MEMORY = ' + str(local_memory))
return response
elif not question:
pronouns = []
nouns = []
verbs = []
adjectives = []
wrb = []
final_word_bank = self.apply_weights(generated_word_bank, question,
sentence, object_name,
detail_name)
#segment everything into question words, nouns and verbs
question_starters = [
'Did', 'How', 'When', 'Where', 'How', 'Can', 'Is', 'What',
'Should', 'Could', 'Would'
]
wp = ['Who', 'What']
wdt = ['Which']
wp_doll = ['Whose']
wrb = ['Where', 'When', 'How']
md = ['Can', 'Could', 'Will', 'Should', 'Would']
q_connect = ['Was', 'Did', 'Is']
q_connect_2 = ['An', 'A', 'It']
q_past = []
q_present = [wdt]
q_future = [md]
q_pro = [wp, wp_doll]
q_where = [wrb]
self_perspective = False
reverse_perspective = False
sentence_bank = []
if 'I' in sentence.split(" "):
self_perspective = True
pronouns.append('I')
if len(final_word_bank[0]) != 0:
pronouns = final_word_bank[0]
sentence_bank.append(pronouns)
if len(final_word_bank[1]) != 0:
nouns = final_word_bank[1]
sentence_bank.append(nouns)
if len(final_word_bank[2]) != 0:
verbs = final_word_bank[2]
sentence_bank.append(verbs)
if len(final_word_bank[3]) != 0:
adjectives = final_word_bank[3]
sentence_bank.append(adjectives)
if len(final_word_bank[6]) != 0:
for verb in final_word_bank[6]:
verbs.append(WordNetLemmatizer().lemmatize(verb, 'v'))
sentence_bank.append(verbs)
if len(final_word_bank[7]) != 0:
for verb in final_word_bank[7]:
verbs.append(WordNetLemmatizer().lemmatize(verb, 'v'))
sentence_bank.append(verb)
if len(final_word_bank[9]) != 0:
wrb = final_word_bank[9]
sentence_bank.append(wrb)
print(pronouns)
print(verbs)
print(nouns)
print(adjectives)
print(wrb)
sentence_RAW = str(pronouns[0] + " " + verbs[0] + " " + nouns[0])
matches = self.tool.check(sentence_RAW)
print(matches)
print(language_check.correct(sentence_RAW, matches))
sentence_tier2 = []
for i, question_starter in enumerate(question_starters):
sentence_tier2.append(question_starters[i] + " " +
sentence_RAW)
print(sentence_tier2)
tool = grammar_check.LanguageTool('en-GB')
matches = tool.check(str(sentence_tier2[0]))
print(matches)
response = grammar_check.correct(str(sentence_tier2[0]), matches)
print(self.get_sentence_tense(self.justTAG(sentence)))
#assign gravity to each set
#combine set gravities into composite gravities for noun verb pairs
#combine set gravities into composite gravities for question noun verb triplets
#filter out final gravity sequence
return response
def do_something(val):
tool = grammar_check.LanguageTool('en-GB')
texts = val
matches = tool.check(texts)
return grammar_check.correct(texts,matches)
def process_one_log(self, input_log, repo_info_topics):
input_log = PreprocessManager.remove_non_ascii(input_log)
# TODO : Do we need repo info?
#repo_info_topics = PreprocessManager.remove_non_ascii(repo_info_topics)
# Find the length
# TODO : All the scores which are dependent on the length are not unbiased if not normalized! Check that
length = len(PreprocessManager.get_raw_tokenized_text(input_log))
# Find structural integrity.
self.grammar_tool.enable_spellchecking()
problematic_matches = self.grammar_tool.check(input_log)
corrected_text = gc.correct(input_log, problematic_matches)
degree_of_match = fuzz.ratio(input_log, corrected_text)
structural_integrity_score = degree_of_match * (length - len(problematic_matches))
# Check if topic is relevant
# This is still in testing phase and not sure if it has a good impact on the final results.
# Might be totally useless at times.
sframe_data_for_topics = gl.SArray([PreprocessManager.get_word_counts(input_log)])
# Add Associations here TODO: Make it proper
associations = gl.SFrame({'word': ['fix', 'issue', 'implement', 'modify', 'changed', 'bug', 'error'],
'topic': [0, 0, 0, 0, 0, 0, 0]})
topic_model = gl.topic_model.create(sframe_data_for_topics, associations=associations)
# TODO : Add here the match with the description. Is that useful? Maybe Future work?
#pred = topic_model.predict(sframe_data_for_topics, output_type='probability')
topics = topic_model.get_topics()
# The final score is the sum of all the topic 0 scores! As they were used in associations. Gives us relevance of being a commit message!
topic_relevance_score = 0
for i in xrange(0, len(topics)):
curr = topics[i]
topic_id = curr['topic']
score_val = curr['score']
if topic_id == 0:
topic_relevance_score += score_val
topic_relevance_score *= 100
#print topics, topic_relevance_score
# Check how much positivity
log_dict = dict()
log_dict['text'] = input_log
positivity = self.senti_checker.predict_row(log_dict)
positivity_score = 100 * positivity
#print positivity_score
# Spelling Goodness
self.spell_master.set_text(input_log)
error_words = list()
for err in self.spell_master:
error_words.append(err.word)
spelling_integrity_score = length - len(error_words)
#return all
return length, structural_integrity_score, topic_relevance_score, positivity_score, spelling_integrity_score
import os
import pytesseract
from PIL import Image
from autocorrect import spell
import grammar_check
text = pytesseract.image_to_string(Image.open("Bruce-Lee-Absorb.png"))
tool = grammar_check.LanguageTool('en-GB')
matches = tool.check(text)
ctext = grammar_check.correct(text, matches)
print ctext
def webook():
# endpoint for processing incoming messaging events
#return "Hello world", 200
data = request.get_json()
log(data) # you may not want to log every incoming message in production, but it's good for testing
if data["object"] == "page":
for entry in data["entry"]:
for messaging_event in entry["messaging"]:
if messaging_event.get("message"): # someone sent us a message
sender_id = messaging_event["sender"]["id"] # the facebook ID of the person sending you the message
if sender_id == u'1774667882802558':
log(sender_id)
return "ok", 200
recipient_id = messaging_event["recipient"]["id"] # the recipient's ID, which should be your page's facebook ID
send_process(sender_id)
send_settings()
message_text = messaging_event["message"].get("text")
option = messaging_event["message"].get("quick_reply")
log(option)
log(grammarUserID)
if grammarUserID.get(sender_id) == 1:
grammarUserID[sender_id] = 0
log(grammarUserID)
tool = grammar_check.LanguageTool('en-US')
tmp = tool.check(message_text)
outp = ''
log(tmp)
#for mis in tmp :
# outp += mis + '\n'
outp = grammar_check.correct(message_text, tmp)
send_message(sender_id, "Correct: " + outp)
return "ok", 200
if option is not None:
opt = messaging_event["message"]["quick_reply"]["payload"]
log(opt)
option_catch(opt,sender_id)
else:
if option is None:
option = messaging_event.get("messaging")
if option is not None:
opt = option[0]["postback"]["payload"]
option_catch(opt,sender_id)
return "ok", 200
if message_text is not None:
if message_text == 'Setting':
quick_replies = [["Volcabulary", "Vocab"], ["Grammar-Check","Gramma"],["Category", "Cate"]]
send_quickReplies(sender_id, "Which option do you choose?", quick_replies)
else:
send_Define(sender_id, message_text)
#else:
#messageType = messaging_event["message"].get("text")
#if messageType == 'audio':
#pass
#change to text
if messaging_event.get("delivery"): # delivery confirmation
pass
if messaging_event.get("optin"): # optin confirmation
pass
if messaging_event.get("postback"): # user clicked/tapped "postback" button in earlier message
pass
return "ok", 200
def webook():
# endpoint for processing incoming messaging events
#return "Hello world", 200
data = request.get_json()
log(
data
) # you may not want to log every incoming message in production, but it's good for testing
if data["object"] == "page":
for entry in data["entry"]:
for messaging_event in entry["messaging"]:
if messaging_event.get("message"): # someone sent us a message
sender_id = messaging_event["sender"][
"id"] # the facebook ID of the person sending you the message
if sender_id == u'1774667882802558':
log(sender_id)
return "ok", 200
recipient_id = messaging_event["recipient"][
"id"] # the recipient's ID, which should be your page's facebook ID
send_process(sender_id)
send_settings()
message_text = messaging_event["message"].get("text")
option = messaging_event["message"].get("quick_reply")
log(option)
log(grammarUserID)
if grammarUserID.get(sender_id) == 1:
grammarUserID[sender_id] = 0
log(grammarUserID)
tool = grammar_check.LanguageTool('en-US')
tmp = tool.check(message_text)
outp = ''
log(tmp)
#for mis in tmp :
# outp += mis + '\n'
outp = grammar_check.correct(message_text, tmp)
send_message(sender_id, "Correct: " + outp)
return "ok", 200
if option is not None:
opt = messaging_event["message"]["quick_reply"][
"payload"]
log(opt)
option_catch(opt, sender_id)
else:
if option is None:
option = messaging_event.get("messaging")
if option is not None:
opt = option[0]["postback"]["payload"]
option_catch(opt, sender_id)
return "ok", 200
if message_text is not None:
if message_text == 'Setting':
quick_replies = [["Volcabulary", "Vocab"],
["Grammar-Check", "Gramma"],
["Category", "Cate"]]
send_quickReplies(
sender_id, "Which option do you choose?",
quick_replies)
else:
send_Define(sender_id, message_text)
#else:
#messageType = messaging_event["message"].get("text")
#if messageType == 'audio':
#pass
#change to text
if messaging_event.get("delivery"): # delivery confirmation
pass
if messaging_event.get("optin"): # optin confirmation
pass
if messaging_event.get(
"postback"
): # user clicked/tapped "postback" button in earlier message
pass
return "ok", 200
requirement += " " + lemma
elif part.tag == "PREP":
if 'value' in part.attrib:
requirement += " " + part.attrib['value']
elif 'value' in part.attrib:
if part.attrib['value'] in extended_parts:
thematicrolepart = random.choice(
extended_parts[part.attrib['value']])
requirement += " " + thematicrolepart
else:
falserequirement = True
break
counter += 1
if falserequirement:
break
if len(requirement) > 7:
matches = tool.check(requirement)
corrected_req = grammar_check.correct(requirement, matches)
new_reqs_file.write(corrected_req)
new_reqs_file.write("\n")
print corrected_req
i += 1
new_reqs_file.close()
else:
print "Files with identified parts of requirements do not exist. Please make sure to run AnalyzeRequirements.py first"
'''
Constructing requirements ends here
'''
def format_question(question):
matches = tool.check(unicode(question))
return grammar_check.correct(unicode(question), matches)
import grammar_check
tool = grammar_check.LanguageTool('en-US')
while True:
text = raw_input("Enter ")
matches = tool.check(text)
print matches
print grammar_check.correct(text, matches)
def grammar(self, essay):
with open(essay, 'r') as text:
self.essay1 = text.read()
tool = grammar_check.LanguageTool('en-GB')
matches = tool.check(self.essay1)
print(grammar_check.correct(self.essay1, matches))
