def summarize(paragraphs, request_dir, model_dir, log_stream):
with open(log_stream, 'a') as f:
f.write('\nBeginning summary\n')
logging.info('Beginning summary: ' + request_dir)
summary = []
for idx, paragraph in enumerate(paragraphs):
with open(log_stream, 'a') as f:
f.write('\nProcessing summary %002d\n' % idx)
# split paragraph up if too big
if len(paragraph) > config.summarizer_max_characters:
step = config.summarizer_max_characters
tmp_summary = ''
for i in range(0, len(paragraph), step):
tmp_summary += summarizer.summarize(paragraph[i:i + step],
request_dir, model_dir,
log_stream)
summary.append(tmp_summary)
else:
summary.append(
summarizer.summarize(paragraph, request_dir, model_dir,
log_stream))
return summary
def SummaryTheText(self, SectionalText, CallNumber=0):
'''
----------
Function
----------
* recievs sectional text
* Cleans the sectional text
* Summarise based on text size
* Saves the summary to Summary.txt file for each section
--------
INPUT
--------
SectionalText = Section Vise text for summarization
CallNumber = Used to iterate over differend files differentiated based on
number (Default = 0)
-------
RETURN
-------
None
'''
OutputFileNamePAth = 'Summary' + str(CallNumber) + '.txt'
logging.info("Inside SummaryCreator")
logging.info("Creating Summary by opening Summary%s.txt", CallNumber)
with open(OutputFileNamePAth, 'w') as f:
text = re.sub("∑", " \n", SectionalText)
text = unidecode(text)
text = re.sub(r'[^\x00-\x7F]+', '', text)
if (len(text) <= 300):
text = summarize('Test', text, count=4)
text = "\n".join(text)
text = re.sub('IntroductionThis', 'Introduction This', text)
else:
text = summarizer.summarize(text, ratio=0.5)
print(len(SectionalText))
print("Summary -->")
print(text)
if (len(text) == 0):
text = summarize('Test', SectionalText, count=4)
text = "\n".join(text)
text = summarizer.summarize(text, ratio=0.6)
text = re.sub("\n", "", text)
f.write(text)
f.close()
logging.info("Summary Created")
logging.info("Exiting SummaryCreator")
def process_article_summaries(db, override=False):
articleCol = db.Article
toSummarizeCol = db.ToSummarize
opts = CodecOptions(unicode_decode_error_handler='ignore')
articleCol = articleCol.with_options(codec_options=opts)
articles = None
skipped = 0
summarized = 0
if override:
articles = articleCol.find()
else:
idsCursor = toSummarizeCol.find({}, { 'article_id': True, '_id': False })
articleIds = [val for val in idsCursor]
articles = articleCol.find({ "$or": articleIds })
for article in articles:
#print("Processing {} ...".format(article['article_id']))
summary = summarize(article['headline'], article['body'])
articleCol.update({ '_id': article['_id'] }, { '$set': { 'summary': summary } })
toSummarizeCol.remove({ 'article_id': article['article_id'] })
summarized += 1
return { 'summarized': summarized, 'skipped': skipped }
def homepage():
if request.method == 'POST':
if "url" in request.form and request.form["url"]:
# Checking if url is in the form.
url = request.form["url"]
title = ""
summary = ""
images = []
try:
res = requests.get(url, headers=HEADERS) # requesting the url.
except RequestException:
title = "Failed to fetch the article content from given link."
if res.status_code == 200:
html_content = res.content
extractor = ContentExtractor(html_content)
content = extractor.content()
title = extractor.title()
images = extractor.images()
summary = summarize(title, str(content))
else:
title = "Page not found."
return render_template("form.html",
data={
"summary": summary,
"title": title,
"images": images
})
return render_template("form.html", data={"summary": "", "title": ""})
def summarized_url():
''' Function that takes in a url and reads the text
and uses beautifulsoup to parse the html and extract
text data from the p tags and generates term
and document frequencies and then ranks them as
important terms which is used as a summary
'''
text_array = []
url_string = [x for x in request.form.values()]
for urls in url_string:
url = urls.lower()
source = requests.get(url).text
soup = BeautifulSoup(source, 'lxml')
for paragraph in soup.find_all('p'):
paragraph = paragraph.text
text_array.append(paragraph)
text = " ".join(text_array)
text = re.sub("[^a-zA-Z.,]", " ", text)
freq_table = summarizer.generate_frequency_table(text)
sentences = sent_tokenize(text)
sentence_scores = summarizer.rank_sentences(sentences, freq_table)
threshold = summarizer.calc_average_rank(sentence_scores)
summary = summarizer.summarize(sentences, sentence_scores, 1.3 * threshold)
return render_template('summarized_url.html', summary=summary)
def generate_feed(self):
"""
Fill the rss feed with `numpost` posts, each with at most 5 comments.
Attempt to make a summary of the post using summarizer.py.
"""
post_ids = self._get_post_ids(self.api)
for pid in post_ids:
post_data = self._get_post_data(pid)
post_title = post_data.get('title', "")
post_score = post_data.get('score', "")
post_author = post_data.get('by', "")
post_kids = post_data.get('kids', "")
post_time = self._format_time(post_data.get('time'))
post_url = post_data.get('url', "")
post_text = post_data.get('text', "")
if not post_text:
post_text = ("<h2>Automated summary of {}.</h2>\n"
"[There may be errors].\n<p>").format(post_url)
try:
with timeout(seconds=15):
post_text += summarizer.summarize(post_url)
logger.debug("No problem occurred during summary")
except TimeoutError:
post_text += "Automated summary timed out. No summary available."
logger.info("Timeout occurred during automated summary.")
except Exception:
post_text += "Unknown error occurred during automated " + \
"summary. No Summary available."
logger.error("Automated summary failed for UNKNOWN reason")
post_text += "</p>"
post_text += (
"<p>Current post score: {}. "
"Full comments are at "
"<a href='https://news.ycombinator.com/item?id={}'>"
"https://news.ycombinator.com/item?id={}</a></p>").format(
post_score, pid, pid)
if post_kids:
post_text += ("<h3> Top Comments </h3><ol>\n\n")
for kid in post_kids[:4]:
kid_data = self._get_post_data(kid)
kid_text = ("<h3><li>{author} at {time}</h3>\n"
"<p>{text}</li>").format(
author=kid_data.get('by', 'Someone'),
time=self._format_time(kid_data.get('time')),
text=kid_data.get('text'))
post_text += kid_text
if post_kids:
post_text += "</ol>\n"
self.feed.append_item(title=post_title,
author=post_author,
link=post_url,
pubDate=post_time,
description=post_text)
def summ(filename):
title = "Test"
with open("/home/deepika/djando-project/speech_recg/mainapp/audio/"+filename.split('.')[0]+"/"+filename.split('.')[0]+".txt",'r') as myFile:
data = myFile.read().replace('\n',' ')
answer = summarize(title,data)
return answer
def process_article_summaries(db, override=False):
col = db.Article
opts = CodecOptions(unicode_decode_error_handler='ignore')
col = col.with_options(codec_options=opts)
articles = None
skipped = 0
summarized = 0
if override:
articles = col.find()
else:
articles = col.find({
"$or": [
{ "summary": { "$size": 0 } },
{ "summary": { "$exists": False } }
],
"body": { "$ne": "" }
})
skipped = col.find({
"summary": {
"$not": { "$size": 0 },
"$exists": True
}
}).count()
for article in articles:
#print("Processing {} ...".format(article['article_id']))
summary = summarize(article['headline'], article['body'])
col.update({ '_id': article['_id'] }, { '$set': { 'summary': summary } })
summarized += 1
return { 'summarized': summarized, 'skipped': skipped }
def summary_file(filename, dictfile):
print('opening filename in summarizing', filename)
if filename.lower().endswith('.txt'):
print('opening text file txt')
try:
with open(filename, 'rt', encoding="utf8") as f:
print('reading file')
text = f.read()
except Exception as e:
print('Terjadi kesalahan dalam membuka file : ', e)
else:
print('nggak mau wkwkwkwkwk')
elif (filename.lower().endswith('.pdf')):
print('pdf', filename)
with pdfplumber.open(filename) as pdf:
total_pages = len(pdf.pages)
text = ''
for page in range(total_pages):
print('extracting pdf page ', page)
loaded_page = pdf.pages[page]
text += loaded_page.extract_text()
with open(dictfile, 'rt') as f:
dictionary = f.read()
print('SEKARANG BUAT SUMMARY')
summary = summarizer.summarize(text, dictionary)
print('summary', summary)
return summary
def summarized_url_api():
''' Function that takes in a url as a json object
and uses beautifulsoup to parse the html and extract
text data from the p tags and generates term
frequencies and document frequencies and then ranks
them as important terms which is used as a summary.
This function is the api endpoint which will be called
and it takes in data in the format {'url': 'the url '}
'''
text_array = []
json_data = request.get_json(force=True)
json_df = json_normalize(json_data)
for urls in json_df.url:
url = urls.lower()
source = requests.get(url).text
soup = BeautifulSoup(source, 'lxml')
for paragraph in soup.find_all('p'):
paragraph = paragraph.text
text_array.append(paragraph)
text = " ".join(text_array)
text = re.sub("[^a-zA-Z0-9.,]", " ", text)
freq_table = summarizer.generate_frequency_table(text)
sentences = sent_tokenize(text)
sentence_scores = summarizer.rank_sentences(sentences, freq_table)
threshold = summarizer.calc_average_rank(sentence_scores)
summary = summarizer.summarize(sentences, sentence_scores, 1.3 * threshold)
return jsonify(summary)
def translate_to_commands(user, user_input):
"""
Function does what process does but for summarize and transcript
The magic numbers in summarize and get_transcript are arbitrary
max messages we get--we do this b/c if not specified, the Spark API
assumes a limit of 50
"""
for i in range(len(user_input)):
input_word = user_input[i]
if input_word in summarizer_keywords:
processed = get_room_name_and_time_limits(user, user_input, i+1)
if processed is not None:
print 'Summarized ' + str(processed)
return summarizer.summarize(user, processed[0], 100, processed[1], processed[2], processed[3])
if input_word in transcript_keywords:
processed = get_room_name_and_time_limits(user, user_input, i+1)
if processed is not None:
print 'Transcript ' + str(processed)
return summarizer.get_transcript(user, processed[0], 500, processed[1], processed[2], processed[3])
if input_word in rename_room_keywords:
processed = process_for_rename_room(user, user_input, i+1)
if processed is not None:
print 'Rename ' + str(processed)
utils.rename_room(user, processed[0], processed[1])
return True
return False
def generate_feed(self):
"""
Fill the rss feed with `numpost` posts, each with at most 5 comments.
Attempt to make a summary of the post using summarizer.py.
"""
post_ids = self._get_post_ids(self.api)
for pid in post_ids:
post_data = self._get_post_data(pid)
post_title = post_data.get('title', "")
post_score = post_data.get('score', "")
post_author = post_data.get('by', "")
post_kids = post_data.get('kids', "")
post_time = self._format_time(post_data.get('time'))
post_url = post_data.get('url', "")
post_text = post_data.get('text', "")
if not post_text:
post_text = ("<h2>Automated summary of {}.</h2>\n"
"[There may be errors].\n<p>").format(post_url)
try:
with timeout(seconds=15):
post_text += summarizer.summarize(post_url)
logger.debug("No problem occurred during summary")
except TimeoutError:
post_text += "Automated summary timed out. No summary available."
logger.info("Timeout occurred during automated summary.")
except Exception:
post_text += "Unknown error occurred during automated " + \
"summary. No Summary available."
logger.error("Automated summary failed for UNKNOWN reason")
post_text += "</p>"
post_text += ("<p>Current post score: {}. "
"Full comments are at "
"<a href='https://news.ycombinator.com/item?id={}'>"
"https://news.ycombinator.com/item?id={}</a></p>"
).format(post_score, pid, pid)
if post_kids:
post_text += ("<h3> Top Comments </h3><ol>\n\n")
for kid in post_kids[:4]:
kid_data = self._get_post_data(kid)
kid_text = ("<h3><li>{author} at {time}</h3>\n"
"<p>{text}</li>").format(
author=kid_data.get('by', 'Someone'),
time=self._format_time(kid_data.get('time')),
text=kid_data.get('text'))
post_text += kid_text
if post_kids:
post_text += "</ol>\n"
self.feed.append_item(title=post_title,
author=post_author,
link=post_url,
pubDate=post_time,
description=post_text)
def parse_wiki(tree, title):
root = tree.getroot()
parser_div = root.xpath("//div[@class='mw-parser-output']")[0]
headers = ["h1","h2","h3","h4","h5","h6"]
children = parser_div.getchildren()
text = ""
header = ""
html = ""
for child in children:
if child.tag == "p":
text += child.text_content().lstrip().rstrip()
elif child.tag in headers:
if len(text) > 0:
summary = summarize(text, limit=2)
html += "<h2>"+header+"</h2><p>"+summary+"</p>"
text = ""
header = child.text_content().split("[")[0]
print(header)
# TODO - add style sheet
# TODO - format text
html_out = E.HTML(
E.HEAD(
E.TITLE(title)
),
E.BODY(
E.H1(E.CLASS("heading"), title),
lxml.html.fromstring(html)
)
)
html_out.getroottree().write(file="summarized-roanoke.html", method="html")
def test_morouns_summary(self):
expected_summary = _read_expected_summary('morouns_s.txt')
actual_summary = summarize(self.morouns['title'], self.morouns['text'])
for actual, expected in zip(actual_summary, expected_summary):
self.assertEqual(actual.replace('\n', ''),
_clean_sentence(expected))
def process_article_summaries(db, override=False):
col = db.Article
opts = CodecOptions(unicode_decode_error_handler='ignore')
col = col.with_options(codec_options=opts)
articles = None
skipped = 0
summarized = 0
if override:
articles = col.find()
else:
articles = col.find({
"$or": [
{ "summary": { "$size": 0 } },
{ "summary": { "$exists": False } }
],
"body": { "$ne": "" }
})
skipped = col.find({
"summary": {
"$not": { "$size": 0 },
"$exists": True
}
}).count()
for article in articles:
#print("Processing {} ...".format(article['article_id']))
summary = summarize(article['headline'], article['body'])
col.update({ '_id': article['_id'] }, { '$set': { 'summary': summary } })
summarized += 1
return { 'summarized': summarized, 'skipped': skipped }
def get_data(company):
data = dict()
# data[company] = {}
# companies = {}
if company in companies:
value = companies[company]
print("company ====", company)
paper = newspaper.build(value['link'], memoize_articles=False)
news_paper = {'link': value['link'], 'articles': []}
count = 1
for content in paper.articles:
if count > 2:
break
try:
content.download()
content.parse()
except Exception as e:
print(e)
print("Continuing")
continue
article = dict()
article['title'] = content.title
article['text'] = content.text
max_value = sent_tokenize(article['text'])
num_sent = 5
summ = summarize()
summary = summ.get_summary(article['text'], num_sent)
article['summary'] = ''.join(summary)
news_paper['articles'].append(article)
count += 1
# data[company] = news_paper
print("========== data============", news_paper)
return news_paper['articles']
def summary_from_article(article, debug=False):
summary_text = ""
if (debug):
print(article.text)
if (len(article.text) > 0):
summary_text = summarize(article.title, article.text)
return ArticleWithSum(article.url, article.title, article.text,
summary_text)
def rest_main():
r = json.loads(request.data)
length = r['summary_length']
summary = s.summarize(r['text'], int(length))
payload = {
"summary": summary
}
return payload
def __init__(self,dataset_name,max_num,seed=41,split="train",aug_methods="summary"):
random.seed(seed)
num_labels = 5
if dataset_name == "imdb":
num_labels = 2
if dataset_name == "ag_news":
num_labels = 4
print(dataset_name)
if dataset_name == "yahoo":
print("here")
num_labels = 10
num_per_class = int(max_num / num_labels)
if dataset_name == "yahoo":
num_per_class = 16
if split == "test":
num_per_class = int(1000 / num_labels)
temp = {i:[] for i in range(num_labels)}
with open ("../processed_data/" + dataset_name + "/seed-{}/".format(int(seed)) + split + "/data") as fin:
text = fin.readlines()
labels = torch.load("../processed_data/" + dataset_name + "/seed-{}/".format(int(seed)) + split + "/labels")
if split=="train" and "+" in aug_methods:
text += text
labels += labels
with open ("../processed_data/" + dataset_name + "/seed-{}/".format(int(seed)) + "train/" + "summary") as fin:
aug_data = fin.readlines()
with open ("../processed_data/" + dataset_name + "/seed-{}/".format(int(seed)) + "train/" + "eda") as fin:
aug_data += fin.readlines()
if split=="train" and "+" not in aug_methods:
with open ("../processed_data/" + dataset_name + "/seed-{}/".format(int(seed)) + "train/" + aug_methods) as fin:
aug_data = fin.readlines()
if split is "test":
aug_data = text
print(len(text))
print(len(labels))
print(len(aug_data))
for i in range(len(text)):
x,y,s = text[i].strip(),labels[i],aug_data[i].strip()
if (split == "train") and (aug_methods == "summary"):
s = s.replace("<q>",". ")
if "....." in s or "this this this" in s or "is is is" in s:
s = summarize(text)
temp[y].append((y,get_clean_line(x),get_clean_line(s)))
self.data = []
for i in range(num_labels):
random.shuffle(temp[i])
self.data += temp[i][:num_per_class]
random.shuffle(self.data)
def vialink():
if request.method == "POST":
textvialink = request.form['Link']
rawtext = articlethroughlink(textvialink)
corpus = []
news = re.sub('[^a-zA-Z]', ' ', rawtext)
news = news.lower()
news = news.split()
news = [lm.lemmatize(word) for word in news if not word in stopword]
news = ' '.join(news)
corpus.append(news)
vectors = tfidf.transform(corpus).toarray()
predictions = model.predict(vectors)
probs = model.predict_proba(vectors)
prob = round((probs.max()) * 100)
inputtext = textvialink
summerized_text = summarize(inputtext)
senti = calsentiment(inputtext)
sentiment = senti[0]
sentiment1 = senti[1]
if sentiment > 0.75:
sentiment_category = "Extremely positive."
elif sentiment > 0.5:
sentiment_category = "Significantly positive."
elif sentiment > 0.3:
sentiment_category = "Fairly positive."
elif sentiment > 0.1:
sentiment_category = "Slightly positive."
elif sentiment < -0.1:
sentiment_category = "Slightly negative."
elif sentiment < -0.3:
sentiment_category = "Fairly negative."
elif sentiment < -0.5:
sentiment_category = "Significantly negative."
elif sentiment < -0.75:
sentiment_category = "Extremely negative."
else:
sentiment_category = "Neutral."
if sentiment1 > 0.75:
sentiment_category1 = "Extremely subjective."
elif sentiment1 > 0.5:
sentiment_category1 = "Fairly subjective."
elif sentiment1 > 0.3:
sentiment_category1 = "Fairly objective."
elif sentiment1 > 0.1:
sentiment_category1 = "Extremely objective."
return render_template('index.html',
result=predictions,
result1=prob,
summerized_text=summerized_text,
polarity=sentiment_category,
subjectivity=sentiment_category1)
def run_lda(self, summarizer, num_topic, num_words):
# Read summary's target lengths. Store them in a map (file_name -> target_length)
len_map = read_len(self.target_length_path)
# Iterate over text directory and use the summarizer.py to generate summaries
for filename in os.listdir(self.body_dir_path):
summary_length = len_map[filename]
summary = summarizer.summarize(self.body_dir_path + filename, summary_length, "lda", num_topic, num_words)
data.export_summary(output_dir_path=self.destination_path, filename=filename, text=summary)
def do_POST(self):
# Doesn't do anything with posted data
self._set_headers()
content_length = int(
self.headers['Content-Length']) # <--- Gets the size of data
post_data = self.rfile.read(content_length).decode()
#print(post_data)
outputText = summarizer.summarize(post_data)
self.wfile.write(outputText.encode("utf-8"))
def index(request):
username = request.user
summarized_text = ''
emphasized_text = ''
keywords = ''
analyzed_words_text = ''
if request.method == 'POST':
form = forms.SimpleForm(request.POST)
username = form['entered_text'].value()
analyzer = morph.MorphAnalyzer(lang='uk')
#text = "Пайтон - інтерпретована об'єктно-орієнтована мова програмування високого рівня зі строгою динамічною типізацією. Розроблена в 1990 році Гвідо ван Россумом. Структури даних високого рівня разом із динамічною семантикою та динамічним зв'язуванням роблять її привабливою для швидкої розробки програм, а також як засіб поєднування наявних компонентів. Python підтримує модулі та пакети модулів, що сприяє модульності та повторному використанню коду. Інтерпретатор Python та стандартні бібліотеки доступні як у скомпільованій, так і у вихідній формі на всіх основних платформах. В мові програмування Python підтримується кілька парадигм програмування, зокрема: об'єктно-орієнтована, процедурна, функціональна та аспектно-орієнтована."
text = username
print(summarize("Python", text, 3))
stopwords = ['а', 'аби', 'абиде', 'абиким', 'абикого', 'абиколи', 'абикому', 'абикуди', 'абихто', 'абичий', 'абичийого', 'абичийому', 'абичим', 'абичию', 'абичия', 'абичиє', 'абичиєму', 'абичиєю', 'абичиєї', 'абичиї', 'абичиїй', 'абичиїм', 'абичиїми', 'абичиїх', 'абичого', 'абичому', 'абищо', 'абияка', 'абияке', 'абиякий', 'абияким', 'абиякими', 'абияких', 'абиякого', 'абиякому', 'абиякою', 'абиякої', 'абияку', 'абиякі', 'абиякій', 'абиякім', 'або', 'абощо', 'авжеж', 'авось', 'ага', 'ад', 'адже', 'аж', 'ажень', 'аз', 'ай', 'але', 'ало', 'амінь', 'ант', 'ану', 'ані', 'аніде', 'аніж', 'анізащо', 'аніким', 'анікого', 'анікогісінько', 'аніколи', 'анікому', 'аніскільки', 'аніхто', 'анічим', 'анічого', 'анічогісінько', 'анічому', 'аніщо', 'аніяка', 'аніяке', 'аніякий', 'аніяким', 'аніякими', 'аніяких', 'аніякого', 'аніякому', 'аніякою', 'аніякої', 'аніяку', 'аніякі', 'аніякій', 'аніякім', 'аніякісенька', 'аніякісеньке', 'аніякісенький', 'аніякісеньким', 'аніякісенькими', 'аніякісеньких', 'аніякісенького', 'аніякісенькому', 'аніякісенькою', 'аніякісенької', 'аніякісеньку', 'аніякісенькі', 'аніякісенькій', 'аніякісенькім', 'аніякісінька', 'аніякісіньке', 'аніякісінький', 'аніякісіньким', 'аніякісінькими', 'аніякісіньких', 'аніякісінького', 'аніякісінькому', 'аніякісінькою', 'аніякісінької', 'аніякісіньку', 'аніякісінькі', 'аніякісінькій', 'аніякісінькім', 'ат', 'ато', 'атож', 'ау', 'ах', 'ач', 'ачей', 'аякже', 'б', 'ба', 'багато', 'багатьма', 'багатьом', 'багатьох', 'баз', 'бай', 'бат', 'бах', 'бац', 'баш', 'бе', 'беж', 'без', 'безперервно', 'бел', 'бер', 'би', 'бир', 'бич', 'близько', 'близько від', 'бо', 'бов', 'бод', 'бодай', 'боз', 'бош', 'був', 'буває', 'буде', 'будем', 'будемо', 'будете', 'будеш', 'буду', 'будуть', 'будь', 'будь ласка', 'будьмо', 'будьте', 'була', 'були', 'було', 'бути', 'бух', 'буц', 'буцім', 'буцімто', 'бі', 'біб', 'більш', 'більше', 'біля', 'в', 'в бік', 'в залежності від', 'в міру', 'в напрямі до', 'в порівнянні з', 'в процесі', 'в результаті', 'в ролі', 'в силу', 'в сторону', 'в супроводі', 'в ході', "в ім'я", 'в інтересах', 'вад', 'важлива', 'важливе', 'важливий', 'важливі', 'вак', 'вам', 'вами', 'ван', 'вас', 'ват', 'ваш', 'ваша', 'ваше', 'вашим', 'вашими', 'ваших', 'вашого', 'вашому', 'вашою', 'вашої', 'вашу', 'ваші', 'вашій', 'вашім', 'ввесь', 'вві', 'вгору', 'вдалині', 'вед', 'верх', 'весь', 'вех', 'вже', 'вздовж', 'ви', 'виз', 'вис', 'височині', 'вище ', 'вйо', 'власне', 'властиво', 'вміти', 'внаслідок', 'вниз', 'внизу', 'во', 'вон', 'вона', 'вони', 'воно', 'восьмий', 'вперед', 'вподовж', 'впоперек', 'впритиск', 'впритул', 'впродовж', 'впрост', 'все', 'всередині', 'всею', 'вслід', 'всупереч', 'всього', 'всьому', 'всю', 'всюди', 'вся', 'всяк', 'всяка', 'всяке', 'всякий', 'всяким', 'всякими', 'всяких', 'всякого', 'всякому', 'всякою', 'всякої', 'всяку', 'всякі', 'всякій', 'всякім', 'всі', 'всій', 'всіляка', 'всіляке', 'всілякий', 'всіляким', 'всілякими', 'всіляких', 'всілякого', 'всілякому', 'всілякою', 'всілякої', 'всіляку', 'всілякі', 'всілякій', 'всілякім', 'всім', 'всіма', 'всіх', 'всією', 'всієї', 'втім', 'ві', 'віг', 'від', 'від імені', 'віддалік від', 'відколи', 'відносно', 'відповідно', 'відповідно до', 'відсотків', 'відтепер', 'відтоді', 'він', 'вісім', 'вісімнадцятий', 'вісімнадцять', 'віт', 'віф', 'віх', 'віц', 'віщо', 'віщось', 'г', 'га', 'гав', 'гаразд', 'ге', 'гез', 'гем', 'геп', 'гет', 'геть', 'гех', 'ги', 'гик', 'гир', 'гич', 'гм', 'го', 'говорив', 'гог', 'гоп', 'гоц', 'гу', 'гуп', 'д', 'да', 'давай', 'давати', 'давно', 'далеко', 'далеко від', 'далі', 'даром', 'два', 'двадцятий', 'двадцять', 'дванадцятий', 'дванадцять', 'двох', 'дві', 'де', "дев'ятий", "дев'ятнадцятий", "дев'ятнадцять", "дев'ять", 'дедалі', 'деким', 'декого', 'деколи', 'декому', 'декотра', 'декотре', 'декотрий', 'декотрим', 'декотрими', 'декотрих', 'декотрого', 'декотрому', 'декотрою', 'декотрої', 'декотру', 'декотрі', 'декотрій', 'декотрім', 'декілька', 'декільком', 'декількома', 'декількох', 'декім', 'десь', 'десятий', 'десять', 'дехто', 'дечий', 'дечийого', 'дечийому', 'дечим', 'дечию', 'дечия', 'дечиє', 'дечиєму', 'дечиєю', 'дечиєї', 'дечиї', 'дечиїй', 'дечиїм', 'дечиїми', 'дечиїх', 'дечого', 'дечому', 'дечім', 'дещо', 'деяка', 'деяке', 'деякий', 'деяким', 'деякими', 'деяких', 'деякого', 'деякому', 'деякою', 'деякої', 'деяку', 'деякі', 'деякій', 'деякім', 'деінде', 'для', 'до', 'добре', 'довго', 'довкола', 'довкіл', 'дог', 'доки', 'допоки', 'допіру', 'досить', 'досі', 'дотепер', 'доти', 'другий', 'друго', 'дуже', 'дякую', 'дійсно', 'діл', 'е', 'еге', 'еж', 'ей', 'ерг', 'ест', 'ет', 'ех', 'еч', 'ж', 'же', 'жоден', 'жодна', 'жодне', 'жодний', 'жодним', 'жодними', 'жодних', 'жодного', 'жодному', 'жодною', 'жодної', 'жодну', 'жодні', 'жодній', 'жоднім', 'жоднісінька', 'жоднісіньке', 'жоднісінький', 'жоднісіньким', 'жоднісінькими', 'жоднісіньких', 'жоднісінького', 'жоднісінькому', 'жоднісінькою', 'жоднісінької', 'жоднісіньку', 'жоднісінькі', 'жоднісінькій', 'жоднісінькім', 'жуз', 'з', 'з метою', 'з нагоди', 'з приводу', 'з розрахунку на', 'з-за', 'з-над', 'з-перед', 'з-поза', 'з-поміж', 'з-понад', 'з-поперед', 'з-посеред', 'з-проміж', 'з-під', 'з-серед', 'за', 'за винятком', 'за допомогою', 'за посередництвом', 'за рахунок', 'завгодно', 'завдяки', 'завжди', 'завше', 'задля', 'зазвичай', 'зайнята', 'зайнятий', 'зайнято', 'зайняті', 'залежно', 'залежно від', 'замість', 'занадто', 'заради', 'зараз', 'зас', 'зате', 'збоку', 'збоку від', 'зважаючи на', 'зверх ', 'зверху', 'звичайно', 'звиш', 'звідки', 'звідкилясь', 'звідкись', 'звідкіль', 'звідкіля', 'звідкілясь', 'звідси', 'звідсіль', 'звідсіля', 'звідти', 'звідтіль', 'звідтіля', 'звідусюди', 'звідусіль', 'звідціля', 'згідно з', 'здається', 'здовж', 'зем', 'зет', 'ззаду', 'зиз', 'зик', 'значить', 'знову', 'зо', 'зовсім', 'зсередини', 'зух', 'зі', 'зіс', 'и', 'ич', 'й', 'ймовірно', 'йно', 'йо', 'його', 'йой', 'йол', 'йому', 'йор', 'йот', 'йох', 'к', 'каже', 'каз', 'кар', 'каф', 'ках', 'ке', 'кед', 'кет', 'кеш', 'кив', 'кий', 'кил', 'ким', 'кимось', 'кимсь', 'ких', 'киш', 'коб', 'коби', 'кого', 'когось', 'кожен', 'кожна', 'кожне', 'кожний', 'кожним', 'кожними', 'кожних', 'кожного', 'кожному', 'кожною', 'кожної', 'кожну', 'кожні', 'кожній', 'кожнім', 'кожнісінька', 'кожнісіньке', 'кожнісінький', 'кожнісіньким', 'кожнісінькими', 'кожнісіньких', 'кожнісінького', 'кожнісінькому', 'кожнісінькою', 'кожнісінької', 'кожнісіньку', 'кожнісінькі', 'кожнісінькій', 'кожнісінькім', 'коли', 'колись', 'коло', 'кому', 'комусь', 'котра', 'котрась', 'котре', 'котресь', 'котрий', 'котрийсь', 'котрим', 'котрими', 'котримись', 'котримось', 'котримсь', 'котрих', 'котрихось', 'котрихсь', 'котрого', 'котрогось', 'котрому', 'котромусь', 'котрою', 'котроюсь', 'котрої', 'котроїсь', 'котру', 'котрусь', 'котрі', 'котрій', 'котрійсь', 'котрім', 'котрімсь', 'котрісь', 'коц', 'коч', 'коштом', 'край', 'краще', 'кру', 'круг', 'кругом', 'крю', 'кря', 'крізь', 'крім', 'куди', 'кудись', 'кудою', 'кілька', 'кільком', 'кількома', 'кількох', 'кім', 'кімось', 'кімсь', 'кінець', 'л', 'лаж', 'лап', 'лас', 'лат', 'ле', 'ледве', 'ледь', 'лет', 'лиш', 'лише', 'лишень', 'лум', 'луп', 'лут', 'льє', 'люди', 'людина', 'ля', 'лі', 'ліворуч від', 'лік', 'лім', 'м', 'мабуть', 'майже', 'мало', 'мати', 'мац', 'ме', 'меж', 'мене', 'менше', 'мені', 'мерсі', 'мет', 'мжа', 'ми', 'мимо ', 'миру', 'мит', 'мною', 'мо', 'мов', 'мовби', 'мовбито', 'могла', 'могли', 'могло', 'мого', 'могти', 'мож', 'може', 'можем', 'можемо', 'можете', 'можеш', 'можна', 'можу', 'можуть', 'можіть', 'мой', 'мол', 'мою', 'моя', 'моє', 'моєму', 'моєю', 'моєї', 'мої', 'моїй', 'моїм', 'моїми', 'моїх', 'му', 'мі', 'міг', 'між', 'мій', 'мільйонів', 'н', 'на', 'на адресу', 'на базі', 'на благо', 'на випадок', 'на відміну від', 'на засадах', 'на знак', 'на зразок', 'на користь', 'на кшталт', 'на межі', 'на основі', 'на противагу', 'на підставі', 'на честь', 'на чолі', 'на ґрунті', 'навколо', 'навкруг', 'навкруги ', 'навкіл', 'навпаки', 'навперейми', 'навпроти', 'навіть', 'навіщо', 'навіщось', 'нагорі', 'над', 'надо', 'надовкола', 'надокола', 'наді', 'назавжди', 'назад', 'назустріч', 'най', 'найбільш', 'нам', 'нами', 'наоколо ', 'наокруг ', 'наокруги ', 'наокіл', 'наперед', 'напередодні', 'напереді', 'наперекір', 'напереріз', 'наприкінці', 'напроти', 'нарешті', 'нарівні з', 'нас', 'насеред', 'насподі', 'наспід', 'настрічу', 'насупроти', 'насупротив ', 'нате', 'наче', 'начеб', 'начебто', 'наш', 'наша', 'наше', 'нашим', 'нашими', 'наших', 'нашого', 'нашому', 'нашою', 'нашої', 'нашу', 'наші', 'нашій', 'нашім', 'не', 'не до', 'не можна', 'неабичим', 'неабичого', 'неабичому', 'неабищо', 'небагато', 'небагатьма', 'небагатьом', 'небагатьох', 'небудь', 'невважаючи', 'невже', 'недалеко', 'недалеко від', 'неж', 'незалежно від', 'незважаючи', 'незважаючи на', 'ней', 'немає', 'немов', 'немовби', 'немовбито', 'неначе', 'неначебто', 'неподалеку', 'неподалеку від', 'неподалечку', 'неподалечку від', 'неподалік', 'неподалік від', 'нерідко', 'нех', 'нехай', 'нещодавно', 'нею', 'неї', 'нижче', 'низько', 'ник', 'ним', 'ними', 'них', 'нич', 'но', 'ну', 'нуг', 'нуд', 'нум', 'нумо', 'нумте', 'ньо', 'нього', 'ньому', 'ню', 'нюх', 'ня', 'няв', 'ні', 'ніби', 'ніби-то', 'нібито', 'ніде', 'ніж', 'нізащо', 'нізвідки', 'нізвідкіля', 'ній', 'ніким', 'нікого', 'нікогісінько', 'ніколи', 'нікому', 'нікотра', 'нікотре', 'нікотрий', 'нікотрим', 'нікотрими', 'нікотрих', 'нікотрого', 'нікотрому', 'нікотрою', 'нікотрої', 'нікотру', 'нікотрі', 'нікотрій', 'нікотрім', 'нікуди', 'нім', 'нінащо', 'ніскільки', 'ніт', 'ніхто', 'нічий', 'нічийна', 'нічийне', 'нічийний', 'нічийним', 'нічийними', 'нічийних', 'нічийного', 'нічийному', 'нічийною', 'нічийної', 'нічийну', 'нічийні', 'нічийній', 'нічийнім', 'нічийого', 'нічийому', 'нічим', 'нічию', 'нічия', 'нічиє', 'нічиєму', 'нічиєю', 'нічиєї', 'нічиї', 'нічиїй', 'нічиїм', 'нічиїми', 'нічиїх', 'нічого', 'нічому', 'ніщо', 'ніяк', 'ніяка', 'ніяке', 'ніякий', 'ніяким', 'ніякими', 'ніяких', 'ніякого', 'ніякому', 'ніякою', 'ніякої', 'ніяку', 'ніякі', 'ніякій', 'ніякім', 'ніякісінька', 'ніякісіньке', 'ніякісінький', 'ніякісіньким', 'ніякісінькими', 'ніякісіньких', 'ніякісінького', 'ніякісінькому', 'ніякісінькою', 'ніякісінької', 'ніякісіньку', 'ніякісінькі', 'ніякісінькій', 'ніякісінькім', 'о', 'об', 'обабіч', 'обаполи', 'обидва', 'обр', 'обік', 'обіруч', 'обіч', 'ов', 'од', 'один', 'одинадцятий', 'одинадцять', 'одна', 'однак', 'одначе', 'одне', 'одним', 'одними', 'одних', 'одно', 'одного', 'одного разу', 'одному', 'одною', 'одної', 'одну', 'одні', 'одній', 'однім', 'однією', 'однієї', 'ож', 'ой', 'окрай', 'окроме', 'округ', 'округи', 'окрім', 'окіл', 'ом', 'он', 'онде', 'онно', 'оно', 'оподаль', 'оподаль від', 'оподалік', 'оподалік від', 'опостін', 'опостінь', 'опроче', 'опріч', 'опріче', 'опісля', 'осе', 'оскільки', 'особливо', 'осторонь', 'ось', 'осісьо', 'от', 'ота', 'отак', 'отака', 'отаке', 'отакий', 'отаким', 'отакими', 'отаких', 'отакого', 'отакому', 'отакою', 'отакої', 'отаку', 'отакі', 'отакій', 'отакім', 'отакісінька', 'отакісіньке', 'отакісінький', 'отакісіньким', 'отакісінькими', 'отакісіньких', 'отакісінького', 'отакісінькому', 'отакісінькою', 'отакісінької', 'отакісіньку', 'отакісінькі', 'отакісінькій', 'отакісінькім', 'отам', 'оте', 'отже', 'отим', 'отими', 'отих', 'ото', 'отого', 'отож', 'отой', 'отому', 'отою', 'отої', 'отсе', 'оттак', 'отто', 'оту', 'отут', 'оті', 'отій', 'отім', 'отією', 'отієї', 'ох', 'оце', 'оцей', 'оцим', 'оцими', 'оцих', 'оцього', 'оцьому', 'оцю', 'оця', 'оці', 'оцій', 'оцім', 'оцією', 'оцієї', 'п', "п'я", "п'ятий", "п'ятнадцятий", "п'ятнадцять", "п'ять", 'па', 'пад', 'пак', 'пек', 'перед', 'передо', 'переді', 'перетака', 'перетаке', 'перетакий', 'перетаким', 'перетакими', 'перетаких', 'перетакого', 'перетакому', 'перетакою', 'перетакої', 'перетаку', 'перетакі', 'перетакій', 'перетакім', 'перший', 'пиж', 'плі', 'по', 'поблизу', 'побік', 'побіля', 'побіч', 'поверх', 'повз', 'повздовж', 'повинно', 'повище', 'повсюди', 'повсюдно', 'подаль від', 'подалі від', 'подекуди', 'подеяка', 'подеяке', 'подеякий', 'подеяким', 'подеякими', 'подеяких', 'подеякого', 'подеякому', 'подеякою', 'подеякої', 'подеяку', 'подеякі', 'подеякій', 'подеякім', 'подовж', 'подібно до', 'поз', 'поза', 'позад', 'позаду', 'позата', 'позате', 'позатим', 'позатими', 'позатих', 'позатого', 'позатой', 'позатому', 'позатою', 'позатої', 'позату', 'позаті', 'позатій', 'позатім', 'позатією', 'позатієї', 'позаяк', 'поздовж', 'поки', 'покрай', 'покіль', 'помежи', 'помимо', 'поміж', 'помість', 'понад', 'понадо', 'понаді', 'понижче', 'пообіч', 'поодаль від', 'поодалік від', 'поперед', 'попереду', 'поперек', 'попліч', 'попри', 'попросту', 'попід', 'пора', 'поруч', 'поряд', 'поряд з', 'порівняно з', 'посеред', 'посередині', 'потрібно', 'потім', 'поуз', 'початку', 'почерез', 'праворуч від', 'пред', 'предо', 'преді', 'прекрасно', 'прецінь', 'при', 'притому', 'причому', 'причім', 'про', 'проз', 'промеж', 'проміж', 'просто', 'проте', 'проти', 'против', 'противно', 'протягом', 'пря', 'пріч', 'пхе', 'пху', 'пі', 'пів', 'півперек', 'під', 'під знаком', 'під приводом', 'під час', 'підо', 'пізніше', 'пім', 'пір', 'після', 'р', 'ради', 'раз', 'разом з', 'разу', 'рано', 'раніш', 'раніш від', 'раніше', 'раніше від', 'раптом', 'ре', 'рет', 'риж', 'рим', 'рип', 'роб', 'року', 'років', 'рос', 'рох', 'році', 'рус', 'рух', 'руч', 'рік', 'с', 'саж', 'саз', 'сак', 'сам', 'сама', 'саме', 'сами', 'самий', 'самим', 'самими', 'самих', 'само', 'самого', 'самому', 'самою', 'самої', 'саму', 'самі', 'самій', 'самім', 'сап', 'сас', 'свого', 'свою', 'своя', 'своє', 'своєму', 'своєю', 'своєї', 'свої', 'своїй', 'своїм', 'своїми', 'своїх', 'свій', 'се', 'себе', 'себто', 'сей', 'сен', 'серед', 'середи', 'середу', 'сеч', 'си', 'сив', 'сиг', 'сиз', 'сик', 'сиріч', 'сих', 'сказав', 'сказала', 'сказати', 'скрізь', 'скільки', 'скільки-то', 'скількись', 'скільком', 'скількома', 'скількомась', 'скількомось', 'скількомсь', 'скількох', 'скількохось', 'скількохсь', 'сли', 'слідом за', 'соб', 'собою', 'собі', 'соп', 'спасибі', 'спереду', 'спочатку', 'справ', 'справді', 'став', 'стосовно', 'стільки', 'стільком', 'стількома', 'стількох', 'су', 'судячи з', 'супроти', 'супротив', 'суть', 'суч', 'суш', 'сьогодні', 'сьомий', 'сюди', 'ся', 'сяг', 'сяк', 'сяка', 'сяке', 'сякий', 'сяким', 'сякими', 'сяких', 'сякого', 'сякому', 'сякою', 'сякої', 'сяку', 'сякі', 'сякій', 'сякім', 'сям', 'сі', 'сім', 'сімнадцятий', 'сімнадцять', 'сіп', 'т', 'та', 'таж', 'так', 'така', 'таке', 'такенна', 'такенне', 'такенний', 'такенним', 'такенними', 'такенних', 'такенного', 'такенному', 'такенною', 'такенної', 'такенну', 'такенні', 'такенній', 'такеннім', 'таки', 'такий', 'таким', 'такими', 'таких', 'такого', 'також', 'такому', 'такою', 'такої', 'таку', 'такі', 'такій', 'такім', 'такісінька', 'такісіньке', 'такісінький', 'такісіньким', 'такісінькими', 'такісіньких', 'такісінького', 'такісінькому', 'такісінькою', 'такісінької', 'такісіньку', 'такісінькі', 'такісінькій', 'такісінькім', 'тал', 'там', 'тамки', 'тамта', 'тамте', 'тамтим', 'тамтими', 'тамтих', 'тамтого', 'тамтой', 'тамтому', 'тамтою', 'тамтої', 'тамту', 'тамті', 'тамтій', 'тамтім', 'тамтією', 'тамтієї', 'тар', 'тат', 'таш', 'тва', 'твого', 'твою', 'твоя', 'твоє', 'твоєму', 'твоєю', 'твоєї', 'твої', 'твоїй', 'твоїм', 'твоїми', 'твоїх', 'твій', 'те', 'тебе', 'тег', 'теж', 'тем', 'тепер', 'теперечки', 'тес', 'теф', 'теє', 'ти', 'тик', 'тил', 'тим', 'тими', 'тисяч', 'тих', 'то', 'тобою', 'тобто', 'тобі', 'того', 'тоді', 'тож', 'той', 'тол', 'тому', 'тому що', 'тот', 'тощо', 'тою', 'тої', 'тра', 'тре', 'треба', 'третій', 'три', 'тринадцятий', 'тринадцять', 'трохи', 'тс', 'тсс', 'ту', 'туди', 'тудою', 'туп', 'тут', 'тутеньки', 'тутечки', 'тутки', 'туф', 'туц', 'тю', 'тюг', 'тюп', 'тяг', 'тяж', 'тям', 'тяп', 'ті', 'тій', 'тільки', 'тім', 'тією', 'у', 'у бік', 'у вигляді', 'у випадку', 'у відповідності до', 'у відповідь на', 'у залежності від', "у зв'язку з", 'у міру', 'у напрямі до', 'у порівнянні з', 'у процесі', 'у результаті', 'у ролі', 'у силу', 'у сторону', 'у супроводі', 'у ході', 'ув', 'увесь', 'уві', 'угу', 'уже', 'узбіч', 'уздовж', 'укр', 'ум', 'унаслідок', 'униз', 'унизу', 'унт', 'уперед', 'уподовж', 'упоперек', 'упритиск до', 'упритул до', 'упродовж', 'упрост', 'ус', 'усе', 'усередині', 'услід', 'услід за', 'усупереч', 'усього', 'усьому', 'усю', 'усюди', 'уся', 'усяк', 'усяка', 'усяке', 'усякий', 'усяким', 'усякими', 'усяких', 'усякого', 'усякому', 'усякою', 'усякої', 'усяку', 'усякі', 'усякій', 'усякім', 'усі', 'усій', 'усіляка', 'усіляке', 'усілякий', 'усіляким', 'усілякими', 'усіляких', 'усілякого', 'усілякому', 'усілякою', 'усілякої', 'усіляку', 'усілякі', 'усілякій', 'усілякім', 'усім', 'усіма', 'усіх', 'усією', 'усієї', 'утім', 'ух', 'ф', "ф'ю", 'фа', 'фаг', 'фай', 'фат', 'фе', 'фед', 'фез', 'фес', 'фет', 'фзн', 'фоб', 'фот', 'фра', 'фру', 'фу', 'фук', 'фур', 'фус', 'фіш', 'х', 'ха', 'хаз', 'хай', 'хап', 'хат', 'хащ', 'хе', 'хет', 'хи', 'хиб', 'хм', 'хо', 'хов', 'хол', 'хон', 'хоп', 'хор', 'хотіти', 'хоч', 'хоча', 'хочеш', 'хро', 'хрю', 'хто', 'хтось', 'ху', 'хуз', 'хук', 'хух', 'хху', 'хіба', 'ц', 'це', 'цебто', 'цей', 'цеп', 'ци', 'цим', 'цими', 'цир', 'цих', 'цло', 'цоб', 'цок', 'цоп', 'цор', 'цс', 'цсс', 'цуг', 'цур', 'цуц', 'цього', 'цьому', 'цю', 'цюк', 'ця', 'цяв', 'цяп', 'ці', 'цід', 'цій', 'цім', 'ціною', 'цією', 'цієї', 'ч', 'чал', 'чар', 'час', 'часто', 'частіше', 'часу', 'чах', 'чей', 'чень', 'через', 'четвертий', 'чи', 'чий', 'чийого', 'чийогось', 'чийому', 'чийомусь', 'чийсь', 'чик', 'чим', 'чимось', 'чимсь', 'чир', 'численна', 'численне', 'численний', 'численним', 'численними', 'численних', 'численні', 'чию', 'чиюсь', 'чия', 'чиясь', 'чиє', 'чиєму', 'чиємусь', 'чиєсь', 'чиєю', 'чиєюсь', 'чиєї', 'чиєїсь', 'чиї', 'чиїй', 'чиїйсь', 'чиїм', 'чиїми', 'чиїмись', 'чиїмось', 'чиїмсь', 'чиїсь', 'чиїх', 'чиїхось', 'чиїхсь', 'чля', 'чого', 'чогось', 'чом', 'чому', 'чомусь', 'чон', 'чоп', 'чортзна', 'чос', 'чотири', 'чотирнадцятий', 'чотирнадцять', 'чу', 'чум', 'чур', 'чш', 'чім', 'чімось', 'чімсь', 'чіт', 'ш', 'ша', 'шаг', 'шал', 'шам', 'шво', 'шед', 'шен', 'шиз', 'шир', 'шляхом', 'шостий', 'шістнадцятий', 'шістнадцять', 'шість', 'щ', 'ще', 'щем', 'щеп', 'щип', 'щир', 'що', 'щоб', 'щоби', 'щодо', 'щойно', 'щоправда', 'щось', 'щі', 'ь', 'ю', 'юз', 'юн', 'юнь', 'юс', 'ют', 'юхт', 'я', 'яв', 'яд', 'яз', 'язь', 'як', 'яка', 'якась', 'якби', 'яке', 'якесь', 'який', 'якийсь', 'яким', 'якими', 'якимись', 'якимось', 'якимсь', 'яких', 'якихось', 'якихсь', 'якого', 'якогось', 'якому', 'якомусь', 'якось', 'якою', 'якоюсь', 'якої', 'якоїсь', 'якраз', 'яку', 'якусь', 'якщо', 'які', 'якій', 'якійсь', 'якім', 'якімсь', 'якісь', 'ял', 'ям', 'ян', 'янь', 'яо', 'яп', 'ярл', 'ясь', 'ять', 'є', 'єр', 'єси', 'і', 'ібн', 'ід', 'із', 'із-за', 'із-під', 'іззаду', 'ізм', 'ізсередини', 'ік', 'ікс', 'ікт', "ім'я", 'імовірно', 'інакша', 'інакше', 'інакший', 'інакшим', 'інакшими', 'інакших', 'інакшого', 'інакшому', 'інакшою', 'інакшої', 'інакшу', 'інакші', 'інакшій', 'інакшім', 'інколи', 'іноді', 'інша', 'інше', 'інший', 'іншим', 'іншими', 'інших', 'іншого', 'іншому', 'іншою', 'іншої', 'іншу', 'інші', 'іншій', 'іншім', 'інь', 'іч', 'іще', 'ї', 'їдь', 'їй', 'їм', 'їх', 'їхнього', 'їхньому', 'їхньою', 'їхньої', 'їхню', 'їхня', 'їхнє', 'їхні', 'їхній', 'їхнім', 'їхніми', 'їхніх', 'її', 'ґ',"в", "для", "на", "але", "можна", "їх", "їхній", "ці", "це", "ця", "інших", "інші", "вони", "як", "це", "ці", "із", "можна", "яка", "для", "а", "й", "але", "повинні", "будь", "не", "так", "сну", "або", "від", "якого", "тому", "без", "як", "при", "їх", "до", "тільки", "см", "абсолютно", "основі", "ви", "під", "щоб", "слід", "також", "та", "у", "як", "об", "з", "для" "в", "з", "об", "що", "с", "і", "має", "із", "для", "та", "за", "на", "який", "яка", "які", "та", "с", "р", "і", "у", "що"]
summarized_text = str(summarize("Python", text, 3))
print(texsum.summarize(text))
emphasized_text = texsum.summarize(text)
print(keysum.keywords(text))
s = keysum.keywords(text)
li = s.split()
keywords = '\n'.join(li) #str(keysum.keywords(text))
text = text.split()
endlist = []
for val in text:
p = analyzer.parse(val)[0]
endlist.append(p.normal_form)
m_dict = {i:endlist.count(i) for i in endlist}
for w in sorted(m_dict, key=m_dict.get, reverse=True):
if analyzer.parse(w)[0].tag.POS != "CONJ" and w not in stopwords:
analyzed_words_text += w + ' ' + str(analyzer.parse(w)[0].tag.POS) + ' ' + str(m_dict[w]) + '\n'
context = {
'username':username,
'summarized_text':summarized_text,
'emphasized_text':emphasized_text,
'keywords':keywords,
'analyzed_words_text':analyzed_words_text
}
return render(request, 'index.html', context)
def predict():
if request.method == 'POST':
article = request.form['inputdata']
if len(article) == 0:
f = request.files['file']
article = fl.fileload(f)
r = 0.5
triplets, sentences, processed = s.parsing(article)
summary = s.summarize(triplets, sentences, processed, r)
cat, _ = s.predict_cat(article)
return render_template('result.html', summary=summary, category=cat)
def addMedicalDataForPatient(self, pin, medicalData):
"""append new medical data for the patient with patientName"""
query = {"pin": pin}
summary = summarizer.summarize(medicalData, True)
self.collection.update_one(
query, {"$push": {"medicalRecord": {"date": datetime.now(), "data": summary}}})
self.collection.update_one(query, {"$inc": {"number_of_visits": 1}})
self.collection.update_one(
query, {"$set": {"curr_sentiment": summary['sentiment']}})
print("Medical Record updated for patient {}".format(pin))
def get_results():
text = request.form['text']
sentences = request.form['sentences_count']
is_summary = 'summary' in request.form
# print(request.form)
# print('is', is_summary)
if is_summary:
return render_template('summary.html',
summary=summarize(text, int(sentences)))
return render_template('keywords.html',
keywords=extract_keywords(text, int(sentences)))
def handle(req):
title = "From Kali to Krishna : A love song"
sentences = summarize(title, req, count=15)
'''
output = ""
format = "[[{}]]\n"
for sentence in sentences:
output += format.format(sentence)
'''
fileObj = StringIO()
json.dump(sentences, fileObj)
return str(fileObj.getvalue())
def summary_write(articles_list):
for article in articles_list:
filename = "outputSummaries/" + article[1] + "_summary_rank.txt"
if not os.path.exists(os.path.dirname(filename)):
try:
os.makedirs(os.path.dirname(filename))
except OSError as exc: # Guard against race condition
if exc.errno != errno.EEXIST:
raise
output = summarize(article[0], language='portuguese')
with open(filename, "w") as f:
f.write(output)
def scrapeToFB():
global previousurl
print("previousurl is " + previousurl)
try:
driver.get(
"https://www.google.com/search?q=site:www.theverge.com+game+%7C+tech&client=firefox-b-d&tbas=0&tbm=nws&source=lnt&tbs=sbd:1&sa=X&ved=0ahUKEwiTh9Tax9riAhW4DmMBHR2TB1wQpwUIIA&biw=1360&bih=654&dpr=1"
)
except:
print("timeout error ")
driver.get(
"https://www.google.com/search?q=site:www.theverge.com+game+%7C+tech&client=firefox-b-d&tbas=0&tbm=nws&source=lnt&tbs=sbd:1&sa=X&ved=0ahUKEwiTh9Tax9riAhW4DmMBHR2TB1wQpwUIIA&biw=1360&bih=654&dpr=1"
)
firstpost = driver.find_element(By.CSS_SELECTOR, ".g > div > a")
firstpost.click()
time.sleep(30)
articletitle = driver.find_element(By.CLASS_NAME, 'c-page-title').text
articledesc2 = summarize(
articletitle,
driver.find_element(
By.XPATH,
"/html/body/div[3]/main/article/div[2]/div[1]/div[1]/p").text +
" " + driver.find_element(
By.XPATH,
"/html/body/div[3]/main/article/div[2]/div[1]/div[1]/p[2]").text)
articledesc = articledesc2[0] + " " + articledesc2[1]
print(articledesc)
print(articletitle)
articleurl = driver.current_url
if articleurl[:90] != previousurl[:90]:
print("articleurl is not equal to previousurl")
previousurl = articleurl
print("new previousurl = " + previousurl)
translator = Translator()
try:
print("attempting to translate")
translate = translator.translate(articletitle, dest='ar')
translate2 = translator.translate(articledesc, dest="ar")
except:
print("error")
translate = translator.translate(articletitle, dest='ar')
translate2 = translator.translate(articledesc, dest="ar")
print("translate succeeded")
print(translate2)
print(translate2.text + "\n" + articleurl)
fbpost(articleurl + "\n" + translate2.text)
else:
print("refreshing")
driver.get(
"https://www.google.com/search?q=site:www.theverge.com+game+%7C+tech&client=firefox-b-d&tbas=0&tbm=nws&source=lnt&tbs=sbd:1&sa=X&ved=0ahUKEwiTh9Tax9riAhW4DmMBHR2TB1wQpwUIIA&biw=1360&bih=654&dpr=1"
)
def run(self, summarizer, tfidf_threshold=0.2, redundancy_threshold=0.95):
# Read summary's target lengths. Store them in a map (file_name -> target_length)
len_map = read_len(self.target_length_path)
# Set up the summarizer
summarizer.set_tfidf_threshold(tfidf_threshold)
summarizer.set_redundancy_threshold(redundancy_threshold)
# Iterate over text directory and use the summarizer.py to generate summaries
for filename in os.listdir(self.body_dir_path):
summary_length = len_map[filename]
summary = summarizer.summarize(self.body_dir_path + filename, summary_length)
data.export_summary(output_dir_path=self.destination_path, filename=filename, text=summary)
def get_facts(user_input):
text_desc = wikipedia.summary(user_input)
text_title = wikipedia.page(user_input).title
# facts for the above article
summ = summarizer.summarize(title=text_title, text=text_desc, count=2)
# clean summ from garbage values
clean_list = [] # empty list for the cleaned facts
for s in summ:
clean_list.append(remove_grabage(s)[0].replace("\n", " "))
return clean_list
def summerised():
# Get URL from browser and shared Summaried on it.
if request.method == 'POST':
news_url = request.form['news_url']
# send text to detact Summary from given URL
article = get_text_from_url(news_url)
summaried_text = summarize(article)
# find the entity from summaried text
entities = str(news_url)
return render_template('index.html',
summaried_text=summaried_text,
entities=entities)
else:
return "Where is the image?"
def summarize(message):
chat_id = str(message.chat.id)
text = re.sub(r'(^\/tldr(audio)?\s*|\s+$)', '', message.text)
if validators.url(text):
logger.info(f'url found {text}')
messages = get_webpage(text)
else:
messages = get_messages(chat_id)
summary = summarizer.summarize(". .", messages)
if len(summary):
summary = '\n'.join(summary)
return summary
def __call__(self, env, start_response):
# While not nessary, webob makes this easy
request = Request(env)
# Call up the middleware pipeline
response = request.get_response(self.app)
# Is the body HTML? (This assumes, our wsgi app is doing sane things
# and setting a DOCTYPE)
if re.match('\s*?<!DOCTYPE\s*?html', response.body):
# If the PATH ends in .tldr
if re.search('\.tldr\s*?$', request.path):
# Summarize the html
response.body = self.summary_html(
summarize(self.number,
self.context,
clean_html(response.body)))
return response(env, start_response)
def test_summarizer_simple(self):
news_article1 = """ A woman and four children were wounded and their apparent attacker killed himself in a mass shooting Wednesday in Bay City, Texas.
The four children were flown to various hospitals, their ages and conditions were not immediately known,
said Lt. Andrew Lewis, spokesman with the Bay City police.
The female shooting victim was undergoing surgery Wednesday evening, Lewis said.
The shooting occurred at a residence in the city outside Houston.
Police responded to a call at 3:18 p.m. (4:18 p.m. ET) that a woman had been shot. When they arrived, they
discovered the other victims and the apparent shooter, Lewis said.
The suspect, a male, had died at the scene after apparently shooting himself in the head, Lewis said.
Detectives are working to determine the relationship of the suspected shooter and the victims, he said. """
# Return 1 sentence from the article
result = summarizer.summarize(num_sentences=1, context_lines=2, text=news_article1)
expected = {'The four children were flown to various hospitals, their ages and conditions were not immediately known, said Lt. Andrew Lewis,'\
' spokesman with the Bay City police.':
[' A woman and four children were wounded and their apparent attacker killed himself in a mass shooting Wednesday in Bay City, Texas.',
'The four children were flown to various hospitals, their ages and conditions were not immediately known, said Lt. Andrew Lewis,'\
' spokesman with the Bay City police.',
'The female shooting victim was undergoing surgery Wednesday evening, Lewis said.', 'The shooting occurred at a residence in the city outside Houston.'
]
}
self.assertEqual(result, expected)
def process_article_summaries(db, override=False):
col = db.Article
articles = col.find()
skipped = 0
summarized = 0
for article in articles:
if not override and 'summary' in article and len(article['summary']) > 0:
print("Already found summary for {}, skipping ...".format(article['headline']), file=sys.stderr)
skipped += 1
continue
print("Processing {} ...".format(article['headline']))
if 'body' not in article or article['body'] == "":
print("Body not found for {}, skipping ...".format(article['headline']), file=sys.stderr)
skipped += 1
continue
body = sanitize(article['body'])
summary = summarize(article['headline'], body)
col.update({ '_id': article['_id'] }, { '$set': { 'summary': summary } })
summarized += 1
return { 'skipped': skipped, 'summarized': summarized }
def test_morouns_summary(self):
expected_summary = _read_expected_summary("morouns_s.txt")
actual_summary = summarize(self.morouns["title"], self.morouns["text"])
for actual, expected in zip(actual_summary, expected_summary):
self.assertEqual(actual.replace("\n", ""), _clean_sentence(expected))
def process(articles, query_db=True, update_all=False):
parser = Parser()
summar = Summarizer(parser)
num_added = 0
num_updated = 0
num_invalid_body = 0
for article in articles:
article_id = article['article_id']
article_headline = article['headline']
article_url = article['url']
body = article.get('body', None)
review = article
if query_db:
review = mongo.db.SummaryReview.find_one({
'article_id': article_id
})
if not body:
art = mongo.db.Article.find_one({ 'article_id': article_id })
if not art or not art['body']:
print("Article {} does not have a body, skipping".format(article_id))
num_invalid_body += 1
continue
body = art['body']
sentences = parser.sentences(body)
summary = summarize(article['headline'], body, count=3, summarizer=summar)
bot_indices = summary_indices(sentences, summary)
if review is None:
mongo.db.SummaryReview.insert({
'article_id': article_id,
'headline': article_headline,
'url': article_url,
'sentences': sentences,
'summary': { 'Bot': bot_indices },
})
num_added += 1
continue
# remove all votes and flags if new sentences dont match old ones
updated = False
if 'sentences' not in review or len(review['sentences']) != len(sentences):
updated = True
else:
for cur_sentence, new_sentence in zip(review['sentences'], sentences):
if cur_sentence != new_sentence:
updated = True
break
if updated or update_all:
review['invalid'] = []
review['summary'] = {
'Bot': bot_indices
}
review['sentences'] = sentences
review['updated_at'] = datetime.utcnow()
review['tokens_valid'] = False
mongo.db.SummaryReview.update({ '_id': review['_id'] }, review)
num_updated += 1
else:
if 'summary' in review:
review['summary']['Bot'] = bot_indices
else:
review['summary'] = { 'Bot': bot_indices }
mongo.db.SummaryReview.update({ '_id': review['_id'] }, review)
print("-" * 80)
print("Articles fetched:\n")
print("\tNumber added: {}".format(num_added))
print("\tNumber updated: {}".format(num_updated))
print("\tNumber invalid body: {}".format(num_invalid_body))
# -*- coding: utf-8 -*-
import sys
from summarizer import summarize, Parser
if __name__ == '__main__':
lines = sys.stdin.readlines()
summary = summarize(lines[0], "".join(lines[1:]))
for sentence in summary:
print(sentence.replace("\n", ""))
def generator(db, cur, tid, portion):
get_entities = "SELECT eid FROM entity where tid=" + str(tid) + " limit 2003,160;"
cur.execute(get_entities)
entities = cur.fetchall()
counter = 1
for entity in entities:
print counter
print entity[0]
get_comments = ["SELECT cid, body, sentiment FROM comment where eid = "
+ str(entity[0]) + " AND sentiment < 0;",
"SELECT cid, body, sentiment FROM comment where eid = "
+ str(entity[0]) + " AND sentiment > 0;"]
for i in xrange(0,len(get_comments)):
query = get_comments[i]
cur.execute(query)
comment_list = []
comment_set = set([])
for c,s,r in cur.fetchall():
count = len(comment_set)
# MetaFilter comments have html labels, get rid of them
if tid == 1:
s = re.sub('<[^<]+?>','',s)
# Convert to unicode
s = s.decode('utf8')
# Get rid of duplicate comments
if len(set(nltk.word_tokenize(s))) > 5:
comment_set.add(s)
if count != len(comment_set):
comment_list.append(CommentInfo(c,s,r))
# If total number of comments is too small, no need to pick representatives
if len(comment_list) < LEAST:
represent = comment_list
else:
num = int(math.ceil(portion*len(comment_list)))
num = max(LEAST,num)
num = min(100,num)
represent = sentiment(SENTIMENT[i],comment_list,num)
for i in xrange(0,len(represent)):
comment = represent[i].sentence
word_list = nltk.word_tokenize(comment)
sentence_list = SENT_TOKENIZER.tokenize(comment)
# Do summarization only if original comment is not short
if len(word_list) > SHORTEST:
num = int(math.ceil(PERCENT*len(sentence_list)))
summary = summarize(comment,num,'lsa')
#print "lsa: " + summary
insert_summary = 'INSERT INTO summary(cid,rank,mid,body) VALUES('+str(represent[i].cid)+','+str(i+1)+','+str(3)+',"'+summary+'");'
#print insert_summary
cur.execute(insert_summary)
summary = summarize(comment,num,'textrank')
#print "textrank: " + summary
insert_summary = 'INSERT INTO summary(cid,rank,mid,body) VALUES('+str(represent[i].cid) + ','+str(i+1)+','+str(4)+',"'+summary+'");'
#print insert_summary
cur.execute(insert_summary)
else:
comment = comment.replace("\\","").replace("\"","\"\"")
insert_original = 'INSERT INTO summary(cid,rank,mid,body) VALUES('+str(represent[i].cid) + ','+str(i+1)+','+str(5)+',"'+comment+'");'
#print "original: " + comment
cur.execute(insert_original)
counter += 1
db.commit()
def textrank(text, summarize_by=SENTENCE, ratio=0.2, words=None):
if summarize_by == SENTENCE:
return summarize(text, ratio, words)
else:
return keywords(text, ratio, words)
from summarizer import summarize
#with open('article.txt', 'r') as f:
with open('article2.txt', 'r') as f:
text = f.read()
test = summarize(text)
def summary_update(db, cur, tid, period, portion):
current = datetime.datetime.now()
last = current - datetime.timedelta(hours=period)
last = last.strftime("%Y-%m-%d %H:%M:%S")
print last
get_entities = "SELECT eid FROM entity where tid="+tid+" AND updated>'"+last+"';"
print get_entities
cur.execute(get_entities)
entities = cur.fetchall()
counter = 1
for entity in entities:
print counter
print entity[0]
deletion = "DELETE summary.* FROM comment INNER JOIN summary ON comment.cid=summary.cid WHERE eid="+str(entity[0]);
print deletion
cur.execute(deletion)
get_comments = ["SELECT cid,body,sentiment FROM comment where eid="
+str(entity[0])+" AND sentiment<0;",
"SELECT cid,body,sentiment FROM comment where eid="
+str(entity[0])+" AND sentiment>0;"]
for i in xrange(0,len(get_comments)):
query = get_comments[i]
print query
cur.execute(query)
comment_list = []
comment_set = set([])
for c,s,r in cur.fetchall():
count = len(comment_set)
# MetaFilter comments have html labels, get rid of them
if tid == '1':
s = s.replace('\\n','')
s = re.sub('<[^<]+?>','',s)
# Convert to unicode
s = s.decode('utf8')
# Get rid of duplicate comments
if len(set(nltk.word_tokenize(s))) > 5:
comment_set.add(s)
if count != len(comment_set):
comment_list.append(CommentInfo(c,s,r))
# If total number of comments is too small, no need to pick representatives
if len(comment_list) < LEAST:
represent = comment_list
else:
num = int(math.ceil(portion*len(comment_list)))
num = max(LEAST,num)
num = min(100,num)
represent = sentiment(SENTIMENT[i],comment_list,num)
for i in xrange(0,len(represent)):
comment = represent[i].sentence
word_list = nltk.word_tokenize(comment)
sentence_list = SENT_TOKENIZER.tokenize(comment)
# Do summarization only if original comment is not short
if len(word_list) > SHORTEST:
num = int(math.ceil(PERCENT*len(sentence_list)))
summary = summarize(comment,num,'lsa')
print "lsa: " + summary
insert_summary = 'INSERT INTO summary(cid,rank,mid,body) VALUES('+str(represent[i].cid)+','+str(i+1)+','+str(3)+',"'+summary+'");'
#print insert_summary
cur.execute(insert_summary)
summary = summarize(comment,num,'textrank')
print "textrank: " + summary
insert_summary = 'INSERT INTO summary(cid,rank,mid,body) VALUES('+str(represent[i].cid) + ','+str(i+1)+','+str(4)+',"'+summary+'");'
#print insert_summary
cur.execute(insert_summary)
else:
comment = comment.replace("\\","").replace("\"","\"\"")
insert_original = 'INSERT INTO summary(cid,rank,mid,body) VALUES('+str(represent[i].cid) + ','+str(i+1)+','+str(5)+',"'+comment+'");'
print "original: " + comment
cur.execute(insert_original)
counter += 1
def process(articles, query_db=True, update_all=False):
from spacyparser import SpacyParser
parser = SpacyParser()
summar = Summarizer(parser)
num_added = 0
num_updated = 0
num_invalid_body = 0
for article in articles:
article_id = article["article_id"]
article_headline = article["headline"]
article_url = article["url"]
body = article.get("body", None)
review = article
if query_db:
review = mongo.db.SummaryReview.find_one({"article_id": article_id})
if not body:
art = mongo.db.Article.find_one({"article_id": article_id})
if not art or not art["body"]:
print("Article {} does not have a body, skipping".format(article_id))
num_invalid_body += 1
continue
body = art["body"]
# sanitize step
body = sanitize(body)
sentences = parser.sentences(body)
summary = summarize(article["headline"], body, count=3, summarizer=summar)
bot_indices = summary_indices(sentences, summary)
if review is None:
mongo.db.SummaryReview.insert(
{
"article_id": article_id,
"headline": article_headline,
"url": article_url,
"sentences": sentences,
"summary": {"Bot": bot_indices},
}
)
num_added += 1
continue
# remove all votes and flags if new sentences dont match old ones
updated = False
if "sentences" not in review or len(review["sentences"]) != len(sentences):
updated = True
else:
for cur_sentence, new_sentence in zip(review["sentences"], sentences):
if cur_sentence != new_sentence:
updated = True
break
if updated or update_all:
review["invalid"] = []
review["summary"] = {"Bot": bot_indices}
review["sentences"] = sentences
review["updated_at"] = datetime.utcnow()
review["tokens_valid"] = False
mongo.db.SummaryReview.update({"_id": review["_id"]}, review)
num_updated += 1
else:
if "summary" in review:
review["summary"]["Bot"] = bot_indices
else:
review["summary"] = {"Bot": bot_indices}
mongo.db.SummaryReview.update({"_id": review["_id"]}, review)
print("-" * 80)
print("Articles fetched:\n")
print("\tNumber added: {}".format(num_added))
print("\tNumber updated: {}".format(num_updated))
print("\tNumber invalid body: {}".format(num_invalid_body))
def semanticSelect(self, table_name, statement, feature, feature_param = None):
"""
semanticSelect is a powerful function which augments the traditional SQL SELECT statment
when users are running SELECT queries over DOCUMENT tables in SemanticTextDB.
Users can pass in a traditional SQL SELECT statement as a string using the statement variable
and pass in a string naming the feature they wish to augment SELECT with.
feature options available are:
1. positive_only - returns tuples corresponding to happy (high sentiment analysis) documents
2. negative_only - returns tuples corresponding to unhappy (low sentiment analysis) documents
3. view_summaries - returns the summaries corresponding to the output of your select statement
4. word_frequency - returns frequency of given word in each document resulting from your query
5. correct_spelling - returns documents with correct spelling for your query.
:param table_name: string declaring name of table the select statment is meant to operate on.
:param statement: a postgreSQL statement as a string (e.g. "SELECT * FROM table_name;")
:param feature: a string naming which feature you wish to augment the select statement with.
:param feature_param: if feature takes in a parameter, pass it in here.
"""
if (table_name[-5:] == "_text" and table_name[:-5] not in self.allDocTables()) or \
(table_name[-5:] != "_text" and table_name not in self.allDocTables()):
raise ValueError("table_name must be a documentTable or the table_text machine generated table.")
if (feature == 'positive_only' or feature == 'negative_only') and feature_param == None:
raise ValueError("features 'positive_only' and 'negative_only' require a feauture_param.")
if (feature == 'view_summaries' or feature == 'word_frequency' or feature == 'correct_spelling') and statement[0:12].upper() == "SELECT COUNT":
raise ValueError("features 'view_summaries' and 'word_frequency' and 'correct_spelling' do not support SELECT COUNT.")
if type(statement) != str:
raise ValueError("statement must be a string.")
if len(statement) < 6 or statement[0:6].upper() != "SELECT":
raise ValueError("statement must begin with 'SELECT'.")
if statement[0:12].upper() == "SELECT COUNT" and statement[0:15].upper() != "SELECT COUNT(*)":
raise ValueError("semanticSelect can only handle aggregates of the form count(*)")
#flag to specify how results are returned
aggregate = statement[0:12].upper() == "SELECT COUNT"
table_text = table_name if table_name[-5:] == "_text" else table_name + "_text"
returnResult = []
if feature == 'positive_only':
count = 0
if aggregate:
self.cursor.execute("SELECT *" + statement[15:]) #REPLACES COUNT(*) WITH *
else:
self.cursor.execute("SELECT id, " + statement[7:])
result = self.cursor.fetchall()
for item in result:
self.cursor.execute("SELECT content FROM " + table_text + " WHERE id = " + str(item[0]))
doc = self.cursor.fetchone()[0]
if nlpf.sentimentAnalysis(doc) >= feature_param:
if aggregate:
count = count + 1
else:
returnResult.append(tuple(list(item)[1:]))
return (count if aggregate else returnResult)
elif feature == 'negative_only':
count = 0
if aggregate:
self.cursor.execute("SELECT *" + statement[15:]) #REPLACES COUNT(*) WITH *
else:
self.cursor.execute("SELECT id, " + statement[7:])
result = self.cursor.fetchall()
for item in result:
self.cursor.execute("SELECT content FROM " + table_text + " WHERE id = " + str(item[0]))
doc = self.cursor.fetchone()[0]
if nlpf.sentimentAnalysis(doc) <= feature_param:
if aggregate:
count = count + 1
else:
returnResult.append(tuple(list(item)[1:]))
return (count if aggregate else returnResult)
elif feature == 'view_summaries':
if feature_param == None:
feature_param = 1
self.cursor.execute("SELECT id, " + statement[7:])
result = self.cursor.fetchall()
for item in result:
self.cursor.execute("SELECT content FROM " + table_text + " WHERE id = " + str(item[0]))
doc = self.cursor.fetchone()[0]
returnResult.append(summarizer.summarize(doc, feature_param))
return returnResult
elif feature == 'word_frequency':
self.cursor.execute("SELECT id, " + statement[7:])
result = self.cursor.fetchall()
for item in result:
self.cursor.execute("SELECT content FROM " + table_text + " WHERE id = " + str(item[0]))
doc = self.cursor.fetchone()[0]
returnResult.append(word_counts(doc))
return returnResult
elif feature == 'correct_spelling':
self.cursor.execute("SELECT id, " + statement[7:])
result = self.cursor.fetchall()
for item in result:
self.cursor.execute("SELECT content FROM " + table_text + " WHERE id = " + str(item[0]))
doc = self.cursor.fetchone()[0]
returnResult.append(str(nlpf.correct_spelling(doc)))
return returnResult
#example of finding ratio of positive to negative support of the royal wedding.
#statement = ('SELECT COUNT(*) FROM twitter, twitter_text '
# 'WHERE twitter.id = twitter_text.id '
# 'AND "london" in twitter_text.text '
# 'AND "wedding" in twitter_text.text')
#posCount = semanticSelect(statement, 'positive_only', 0.8)
#negCount = semanticSelect(statement, 'negative_only', -0.8)
#ratio = posCount / (1.0 * negCount)
ldaResults.append(lda.runLDA(data_this_level))
lda_intertimes.append(time.time() - start_time)
summaryResults = []
sentimentResults = []
sentiment_total_time = 0
summary_total_time = 0
for item in data_this_level:
start_time = time.time()
sentimentResults.append(nlpf.sentimentAnalysis(item))
sentiment_total_time = sentiment_total_time + (time.time() - start_time)
start_time = time.time()
summaryResults.append(s.summarize(item))
summary_total_time = summary_total_time + (time.time() - start_time)
summary_intertimes = [summary_total_time]
sentiment_intertimes = [sentiment_total_time]
print trial, level
lda_trials.append(lda_intertimes)
summary_trials.append(summary_intertimes)
sentiment_trials.append(sentiment_intertimes)
time_elapsed = time.time() - base_time
print 'Trial Completed:', trial + 1
print "Estimated Minutes Left:", (time_elapsed * NUM_TRIALS / (trial + 1.0) - time_elapsed) / 60.0
print "Time Elapsed:", time_elapsed
def insertDoc(self, text, table_name, user_column_vals = [], id = None,
new_transaction = True, persist_updates = False):
""" Inserts a document into the DB and automatically updates
models if necessary.
:param text: the text of the document (string)
:param table_name: the name of the document-table in which this
document should be inserted.
:param user_column_vals: A list whose elements are the values
corresponding to user-specified fields established during the
creation of the document-table.
:param id: an integer which cannot be an existing document id in the DB.
Generally id = None should be used to allow the document table to
self-manage the assigment of ids to documents.
:param new_transaction: Boolean specifying whether a new transaction
should be created for the operations in this function
(set to True if this insert is not part of a larger Transaction).
:param persist_updates: Should the online parameter updates to the large models
be persisted to disk? For faster insertion , only persist to disk at the end of
"""
if table_name not in self.document_tables:
raise LookupError(table_name + " is an unknown document table")
if new_transaction:
self.cursor.execute("BEGIN;")
# Insert into document table
command = "INSERT INTO " + table_name + " VALUES ("
if id is None:
command += "DEFAULT"
else:
command += str(id)
for val in user_column_vals:
if isinstance(val, basestring):
# wrap in quotes for Postgres string and format safely
# Note this is NOT safe against SQL injection,
# so untrusted user-strings should always be sanitized before calling
# insertDoc. Here $zxqy9$ is a (highly-unlikely-naturally-occuring)
# quote-delimiter which is not allowed to appear in the contents of the text.
command = command + ", " + "$zxqy9$" + val + "$zxqy9$"
else:
command = command + ", " + str(val)
command += ", clock_timestamp()"
if self.document_tables[table_name].length_count_option:
command += ", NULL" # TODO: Implement length-counting
if self.isOptionOn('sentiment', table_name):
command += ", " + str(nlpf.sentimentAnalysis(text))
if self.isOptionOn('summary', table_name):
command += ", " + "$zxqy9$" + summarizer.summarize(text,
summary_length = self.getOption('summary', table_name)) + "$zxqy9$"
command += ");"
self.cursor.execute(command)
# Insert text:
command = "INSERT INTO " + table_name + "_text VALUES ("
if id is None:
command += "DEFAULT"
else:
command += str(id)
# wrap in quotes for Postgres string and format safely
# Note this is NOT safe against SQL injection,
# so untrusted texts should always be sanitized before calling
# insertDoc. Here $zxqy9$ is a (highly-unlikely-naturally-occuring)
# quote-delimiter which is not allowed to appear in the contents of the text.
command = command + ", " + "$zxqy9$" + text + "$zxqy9$);"
self.cursor.execute(command)
# Check whether models should be updated and if so, perform the necessary updates:
self.updateModels(table_name, text)
if new_transaction:
self.cursor.execute("COMMIT;")
