def signup_post():
email = request.form.get('email')
username = request.form.get('username')
password = request.form.get('password')
print("Signup for: ", request.form.get("email"),
request.form.get('username'), request.form.get('password'))
user = DBConn().select_user(
username
) # if this returns a user, then the email already exists in database
# TODO login vs signup pages
if user: # if a user is found, we want to redirect back to signup page so user can try again
flash('User already exists')
return redirect(url_for('login_page'))
# create new user with the form data. Hash the password so plaintext version isn't saved.
hash_pass = generate_password_hash(password)
new_user = DBUser(username=username, email=email)
# add the new user to the database
DBConn().insert_user(new_user, hash_pass)
return redirect(url_for('login_page'))
def test_select_category_articles(self):
exp_articles = [(1, 'a'), (3, 'c')]
act_articles = DBConn(
TestDBConn.DB_FILENAME).select_category_articles('y_b')
self.assertEqual(exp_articles, act_articles)
exp_articles = [(1, 'a'), (2, 'b'), (3, 'c')]
act_articles = DBConn(
TestDBConn.DB_FILENAME).select_category_articles('tegor')
self.assertEqual(exp_articles, act_articles)
def test_select_tunit_category_exists(self):
exp_t_unit_list = [
TUnit('sentence_a', 1, 'url', 1234, 1, 18.1, -66.7, 0, 0, 0),
TUnit('sentence_b', 2, 'url', 1234, 2, 30.0, 30.25, 1, 1, 1)
]
act_t_unit_list = DBConn(
TestDBConn.DB_FILENAME).select_tunit_category('y_a')
self.assertEqual(exp_t_unit_list, act_t_unit_list)
exp_t_unit_list = [
TUnit('sentence_a', 1, 'url', 1234, 1, 18.1, -66.7, 0, 0, 0),
TUnit('sentence_b', 2, 'url', 1234, 2, 30.0, 30.25, 1, 1, 1),
TUnit('sentence_c', 3, 'url', 1234, 3, -1.0, 30.0, 2, 2, 2)
]
act_t_unit_list = DBConn(
TestDBConn.DB_FILENAME).select_tunit_category('category')
self.assertEqual(exp_t_unit_list, act_t_unit_list)
def test_insert_user(self):
exp_user = DBUser(username='******', email='*****@*****.**')
exp_password = '******'
user_id = DBConn(TestDBConn.DB_FILENAME).insert_user(
exp_user, exp_password)
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
query = '''
SELECT *
FROM user
WHERE user_id = ?
'''
rows = conn.cursor().execute(query, (user_id, )).fetchall()
conn.close()
self.assertEqual(len(rows), 1)
row = rows[0] # row: (1, 'Jim', 'jim@email', 'pass', 0, 0, 0, 0)
exp_user.user_id = row[0]
act_user = DBUser(user_id=row[0],
username=row[1],
email=row[2],
wins=row[4],
losses=row[5],
num_answered=row[6],
num_answered_correct=row[7])
act_password = row[3]
self.assertEqual(exp_user, act_user)
self.assertEqual(exp_password, act_password)
def test_select_tunit_location_exists(self):
exp_t_unit_list = [
TUnit('sentence_a', 1, 'url', 1234, 1, 18.1, -66.7, 0, 0, 0)
]
act_t_unit_list = DBConn(
TestDBConn.DB_FILENAME,
TestDBConn.SEARCH_RADIUS).select_tunit_location('00601')
self.assertEqual(exp_t_unit_list, act_t_unit_list)
def test_select_tunit_random(self):
exp_t_unit_list = [
TUnit('sentence_a', 1, 'url', 1234, 1, 18.1, -66.7, 0, 0, 0),
TUnit('sentence_b', 2, 'url', 1234, 2, 30.0, 30.25, 1, 1, 1),
TUnit('sentence_c', 3, 'url', 1234, 3, -1.0, 30.0, 2, 2, 2),
TUnit('sentence_d', 4, 'url', 1234, 4, -1.0, 30.25, 3, 3, 3)
]
act_t_unit = DBConn(TestDBConn.DB_FILENAME).select_tunit_random()
self.assertIn(act_t_unit, exp_t_unit_list)
def test_delete_category(self):
category = 'category_a'
DBConn(TestDBConn.DB_FILENAME).delete_category(category)
query = '''
SELECT *
FROM category
WHERE name = ?'''
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
act_category = conn.cursor().execute(query, (category, )).fetchone()
self.assertIsNone(act_category)
def login_post():
username = request.form.get('username')
password = request.form.get('password')
# TODO implement this?
#remember = True if request.form.get('remember') else False
remember = False
user = DBConn().select_user(username)
if user is not None and check_password_hash(
DBConn().select_password(user.username), password):
print("Logging user", username, "in")
session.permanent = True
session['username'] = user.username
return redirect(url_for('index'))
flash('Please check your login details and try again.')
return redirect(url_for('login_page'))
def _get_article_features(page_html: str,
url: str,
access_timestamp: int,
article_id: int = 1,
importance: float = -1) -> Article:
"""Parses the features of Article from the page html.
:param page_html: the HTML of the page.
:type page_html: str
:param url: the URL of the page.
:type url: str
:param access_timestamp: the Unix timestamp at which the page was accessed.
:type access_timestamp: int
:param article_id: the ID of the article in the database.
:type article_id: int.
:returns: the Article object representing the Wikipedia page.
"""
soup = bs4.BeautifulSoup(page_html, features="html.parser")
content = ''
for tag in soup.findAll('p'):
span_tags = tag.findAll('span')
# Check if there is LaTeX in the paragraph tag.
for span in span_tags:
if span.has_attr('mwe-math-element'):
break
else:
content += ''.join(tag.strings) + '\n'
content = preprocess_text(content)
content = features.resolve_coreferences(content)
# Get categories from original Wikipedia article.
categories = DBConn().select_article_categories(article_id)
# Convert list of tuples to list of strings.
categories = [category[0] for category in categories]
# categories_div = soup.find('div', {'id': 'mw-normal-catlinks'})
# if categories_div.ul.children:
# for li in categories_div.ul.children:
# categories.append(li.text)
long_span = soup.find('span', {'class': 'longitude'})
lat_span = soup.find('span', {'class': 'latitude'})
if long_span and lat_span:
longitude = convert_dms_to_decimal(long_span.text)
latitude = convert_dms_to_decimal(lat_span.text)
else:
longitude = None
latitude = None
article = Article(content, url, article_id, categories, importance,
access_timestamp, latitude, longitude)
return article
def test_insert_category(self):
exp_category = ('category', 1.5)
DBConn(TestDBConn.DB_FILENAME).insert_category(*exp_category)
query = '''
SELECT name, importance
FROM category
WHERE name = ?'''
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
act_category = conn.cursor().execute(query,
(exp_category[0], )).fetchone()
self.assertEqual(exp_category, act_category)
def test_delete_tunit(self):
t_unit = TUnit('sentence_a', 1, 'url', 1234, 1, 30, 30, 0, 0, 0)
DBConn(TestDBConn.DB_FILENAME).delete_tunit(t_unit)
query = '''
SELECT t_unit_Id
FROM t_unit
WHERE t_unit_Id = ?
'''
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
row = conn.cursor().execute(query, (1, )).fetchone()
self.assertIsNone(row)
def test_delete_user(self):
user = DBUser(0, 'Jill', '*****@*****.**', 5, 5, 10, 5)
DBConn(TestDBConn.DB_FILENAME).delete_user(user)
query = '''
SELECT username
FROM user
WHERE username = ?
'''
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
act_user = conn.cursor().execute(query, (user.username, )).fetchone()
self.assertIsNone(act_user)
def test_update_password(self):
exp_username = '******'
exp_password = '******'
DBConn(TestDBConn.DB_FILENAME).update_password(exp_username,
exp_password)
query = '''
SELECT username, password
FROM user
WHERE username = ?
'''
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
act_username, act_password = conn.cursor().execute(
query, (exp_username, )).fetchone()
self.assertEqual(exp_username, act_username)
self.assertEqual(exp_password, act_password)
def test_select_random_article(self):
observations = {}
for j in range(10000):
article_id, article_text = DBConn(
TestDBConn.DB_FILENAME).select_random_article()
self.assertEqual(article_id, ord(article_text) - 96)
if article_id in observations.keys():
observations[article_id] += 1
else:
observations[article_id] = 1
act_chisq, p = chisquare(list(observations.values()))
# NOTE(Alex): This value is retrieved from a chi square critical value chart with 9 degrees of freedom
# (10 articles - 1) and using a P value of 0.01
exp_max_chisq = 21.67
self.assertLess(act_chisq, exp_max_chisq)
def test_update_tunit_does_not_exist(self):
exp_t_unit = TUnit('sentence', 1, 'url', 1234, None, 10, 10, 0, 0, 0)
t_unit_Id = DBConn(TestDBConn.DB_FILENAME).update_tunit(exp_t_unit)
self.assertEqual(t_unit_Id, exp_t_unit.t_unit_id)
conn = sqlite3.connect(TestDBConn.DB_FILENAME)
query = """
SELECT sentence, article_id, url, access_timestamp, t_unit_Id, lat, long, num_likes, num_mehs,
num_dislikes
FROM t_unit
WHERE t_unit_Id = ?;
"""
row = conn.cursor().execute(query, (t_unit_Id, )).fetchone()
conn.close()
act_t_unit = TUnit(*row)
self.assertEqual(exp_t_unit, act_t_unit)
def get_page_by_random() -> Article:
"""Gets the contents and metadata of a random Wikipedia article.
:returns: the Article object representing the Wikipedia article.
"""
article_id, title = None, None
page_html = None
url = None
while page_html is None:
article_id, title, importance = DBConn(
).select_weighted_random_article()
url = BASE_URL + title.replace(' ', '_')
page_html = _get_page_from_title(title)
access_timestamp = int(time.time())
article = _get_article_features(page_html, url, access_timestamp,
article_id, importance)
return article
def get_page_by_category(category: str) -> Article:
"""Gets the contents and metadata of a Wikipedia article with a given category.
:param category: the category with which to search.
:type category: str
:returns: the Article obj ect representing the Wikipedia article.
"""
articles_with_category = DBConn().select_category_articles(category)
print("articles by category:", articles_with_category)
if not articles_with_category:
return None
article_id, title = random.choice(articles_with_category)
url = BASE_URL + title.replace(' ', '_')
page_html = _get_page_from_title(title)
access_timestamp = int(time.time())
article = _get_article_features(page_html, url, access_timestamp,
article_id)
return article
def get_page_by_location_zip(zip_code: str):
"""Gets the contents and metadata of a a Wikipedia article close to the given zip code.
:param zip_code: the zipcode of the desired location, as a string
:returns: the Article object representing the Wikipedia article
"""
article_id, title = None, None
page_html = None
url = None
while page_html is None:
article_list = DBConn().select_articles_location(zip_code)
print("location article list: ", article_list)
if article_list is None or len(article_list) == 0:
print("didn't find anything at zip", zip_code)
return None
article_id, title = random.choice(article_list)
url = BASE_URL + title.replace(' ', '_')
page_html = _get_page_from_title(title)
access_timestamp = int(time.time())
article = _get_article_features(page_html, url, access_timestamp,
article_id)
return article
def test_update_user_does_not_exist(self):
user = DBUser(username='******', email='*****@*****.**')
exp_user_id = -1
act_user_id = DBConn(TestDBConn.DB_FILENAME).update_user(user)
self.assertEqual(exp_user_id, act_user_id)
def test_select_user_does_not_exist(self):
act_user = DBConn(TestDBConn.DB_FILENAME).select_user('bum')
self.assertIsNone(act_user)
def test_select_user_exists(self):
exp_user = DBUser(1, 'Jill', '*****@*****.**', 5, 5, 10, 5)
act_user = DBConn(TestDBConn.DB_FILENAME).select_user('Jill')
self.assertEqual(exp_user, act_user)
from flask import Flask, render_template, request
from flask_socketio import SocketIO
top_level_dir = os.path.abspath('../')
sys.path.append(top_level_dir)
from trivia_generator.web_scraper.WebScraper import get_page_by_random
from trivia_generator.NLPPreProcessor import create_TUnits
from database_connection.dbconn import DBConn
app = Flask(__name__)
socketio = SocketIO(app)
tunit_dictionary = dict()
dbconn = DBConn()
@app.route('/')
@app.route('/index')
def index():
return render_template("index.html")
@socketio.on('update_rank')
def update_rank(rank):
try:
tunit = tunit_dictionary[request.sid]
if rank == 'like':
tunit.num_likes += 1
elif rank == 'dislike':
def test_select_tunit_category_does_not_exist(self):
exp_t_unit_list = []
act_t_unit_list = DBConn(
TestDBConn.DB_FILENAME).select_tunit_category('does not exist')
self.assertEqual(exp_t_unit_list, act_t_unit_list)
def test_select_tunit_location_does_not_exist(self):
exp_t_unit_list = []
act_t_unit_list = DBConn(
TestDBConn.DB_FILENAME,
TestDBConn.SEARCH_RADIUS).select_tunit_location('75163')
self.assertEqual(exp_t_unit_list, act_t_unit_list)
def test_select_password(self):
exp_password = '******'
act_password = DBConn(TestDBConn.DB_FILENAME).select_password('Jill')
self.assertEqual(exp_password, act_password)
def test_select_articles_location(self):
exp_articles = [(1, 'a')]
act_articles = DBConn(
TestDBConn.DB_FILENAME,
TestDBConn.SEARCH_RADIUS).select_articles_location('00601')
self.assertEqual(exp_articles, act_articles)
def test_select_articles_location_does_not_exist(self):
exp_articles = []
act_articles = DBConn(
TestDBConn.DB_FILENAME).select_articles_location('25974')
self.assertEqual(exp_articles, act_articles)
def test_select_article_categories(self):
article_id = 1
exp_categories = ['category_a', 'category_b', 'category_c']
act_categories = DBConn(
TestDBConn.DB_FILENAME).select_article_categories(article_id)
self.assertEqual(exp_categories, act_categories)
