564 lines
17 KiB
Python
564 lines
17 KiB
Python
# app.py
|
|
from flask import Flask, request, jsonify, send_file
|
|
import random
|
|
from datetime import date, datetime # used for daily verse
|
|
import sqlite3
|
|
import string # for literals
|
|
import json # for dictionary
|
|
import hunspell # for spell checking
|
|
|
|
DEBUG = 2
|
|
|
|
"""
|
|
To-do:
|
|
Separate dictionary-dictionary for hunsepll
|
|
Search phrase alias
|
|
Response Bible book reading
|
|
Search highlighting
|
|
Styles
|
|
Bible Reading Plan
|
|
Bible Reader
|
|
Rich: <hr> on each comma
|
|
find: handle ending with ,
|
|
"""
|
|
|
|
|
|
def dbg(message):
|
|
if DEBUG >= 1:
|
|
print(f"\033[91m{message}\033[0m")
|
|
|
|
|
|
def dbg2(message):
|
|
if DEBUG >= 2:
|
|
print(f" \033[32m{message}\033[0m")
|
|
|
|
|
|
def dbg3(message):
|
|
if DEBUG >= 3:
|
|
print(f" \033[35m{message}\033[0m")
|
|
|
|
|
|
dbg("Debug Level 1 Enabled")
|
|
dbg2("Debug Level 2 Enabled")
|
|
dbg3("Debug Level 3 Enabled")
|
|
|
|
dictionary_json = "data/1828_Webster_KJV.json"
|
|
kjv_cur = sqlite3.connect("data/kjv.db").cursor()
|
|
verse_ids = [i[0] for i in kjv_cur.execute("SELECT id FROM fts_kjv;").fetchall()]
|
|
book_names = [i[0] for i in kjv_cur.execute("SELECT n FROM key_english").fetchall()]
|
|
|
|
app = Flask(__name__)
|
|
|
|
idx_id = 0
|
|
idx_book = 1
|
|
idx_chapter = 2
|
|
idx_verse = 3
|
|
idx_text = 4
|
|
|
|
|
|
def lookup_one_verse(verse_id):
|
|
dbg2("lookup_one_verse({})".format(verse_id))
|
|
return kjv_cur.execute(
|
|
"SELECT * FROM fts_kjv WHERE id = {};".format(verse_id)
|
|
).fetchone()
|
|
|
|
|
|
def lookup_bookname(book_id):
|
|
dbg3("lookup_bookname({})".format(book_id))
|
|
result = kjv_cur.execute(
|
|
"SELECT n FROM key_english WHERE b = {};".format(book_id)
|
|
).fetchone()
|
|
if result:
|
|
result = result[0]
|
|
dbg3("lookup_bookname.result = '{}'".format(result))
|
|
return result
|
|
|
|
|
|
def lookup_book_id(bookname):
|
|
dbg3("lookup_book_id({})".format(bookname))
|
|
result = kjv_cur.execute(
|
|
"SELECT b FROM key_english WHERE n = '{}';".format(bookname)
|
|
).fetchone()
|
|
if result:
|
|
result = result[0]
|
|
dbg3("lookup_book_id.result = '{}'".format(result))
|
|
return result
|
|
|
|
|
|
def lookup_fts(kwds):
|
|
dbg3("lookup_fts.kwds = '{}'".format(kwds))
|
|
return kjv_cur.execute("SELECT * FROM fts_kjv('{}')".format(kwds)).fetchall()
|
|
|
|
|
|
def lookup_contains(kw):
|
|
results = kjv_cur.execute(
|
|
"SELECT * FROM fts_kjv WHERE t LIKE '%{}%';".format(kw)
|
|
).fetchall()
|
|
dbg2("lookup_contains({}) {} results".format(kw, len(results)))
|
|
return results
|
|
|
|
|
|
def lookup_by_verse_id(start_verse, end_verse=None):
|
|
if not end_verse:
|
|
results = kjv_cur.execute(
|
|
"SELECT * FROM fts_kjv WHERE id = {};".format(start_verse)
|
|
).fetchall()
|
|
else:
|
|
results = kjv_cur.execute(
|
|
"SELECT * FROM fts_kjv WHERE id BETWEEN {} AND {};".format(
|
|
start_verse, end_verse
|
|
)
|
|
).fetchall()
|
|
return results
|
|
|
|
|
|
def get_verse_id(book_id, chapter, verse):
|
|
# verse_id is 00000000 (00 000 000) (book + chapter + verse)
|
|
chapterid = chapter.zfill(3)
|
|
verseid = verse.zfill(3)
|
|
return str(book_id) + chapterid + verseid
|
|
|
|
|
|
def check_lone_word(text, kw):
|
|
kw_length = len(kw)
|
|
kw_location = text.find(kw)
|
|
try:
|
|
if (text[kw_location - 1]).isalpha():
|
|
return False
|
|
except IndexError:
|
|
# If it's an indexerror, it's likely that
|
|
# the keyword is at the end or beginning
|
|
# of the text.
|
|
pass
|
|
try:
|
|
if (text[kw_location + kw_length]).isalpha():
|
|
return False
|
|
except IndexError:
|
|
pass
|
|
return True
|
|
|
|
|
|
def lookup_contains_exact(kw):
|
|
preresult = lookup_contains(kw)
|
|
results = []
|
|
for result in preresult:
|
|
if check_lone_word(result[idx_text], kw):
|
|
results.append(result)
|
|
dbg("lookup_contains({}) {} results".format(kw, len(results)))
|
|
return results
|
|
|
|
|
|
def ref_input_cleaning(
|
|
ref, valid_chars=(string.ascii_letters + string.digits + ":-,"), ref_search=True
|
|
):
|
|
dbg3("ref_input_cleaning({})".format(ref))
|
|
ref = ref.replace(" ", "")
|
|
if ref.count(":") != 1 and ref_search:
|
|
dbg2("ref_input_cleaning.if ref.count(:): TRUE")
|
|
dbg2(" -> Assuming user wanted entire chapter")
|
|
ref += ":-"
|
|
if ref.endswith(":"):
|
|
ref += "-"
|
|
if ref.count("-") > 1 and ref_search:
|
|
dbg2("ref_input_cleaning.if ref.count(-): TRUE")
|
|
return False
|
|
if not ref[-1].isdigit() and ref[-1] != "-" and ref_search:
|
|
dbg2("ref_input_cleaning.if ref[-1] TRUE")
|
|
return False
|
|
ref = list(ref)
|
|
# preserve book number if we can guess the first
|
|
# character is a number and 3nd is a letter
|
|
if ref[0].isdigit() and ref[1].isalpha() and ref_search:
|
|
prefix = ref.pop(0) + " "
|
|
else:
|
|
prefix = ""
|
|
# clean the rest of the reference
|
|
cleaned_ref = []
|
|
for character in ref:
|
|
if character in valid_chars:
|
|
cleaned_ref.append(character)
|
|
# Was there a problem?
|
|
if len(cleaned_ref) == 0:
|
|
return False
|
|
if ref_search:
|
|
return prefix + "".join(cleaned_ref).capitalize()
|
|
else:
|
|
return "".join(cleaned_ref)
|
|
|
|
|
|
def search_input_cleaning(
|
|
query, valid_chars=string.ascii_letters + string.digits + '+^" '
|
|
):
|
|
cleaned_query = []
|
|
for character in query:
|
|
if character in valid_chars:
|
|
cleaned_query.append(character)
|
|
return "".join(cleaned_query)
|
|
|
|
|
|
def ref_parse_book(ref):
|
|
for book in reversed(book_names):
|
|
if book.startswith(ref):
|
|
return book
|
|
return False
|
|
|
|
|
|
@app.get("/find")
|
|
def parse_query():
|
|
query = request.args.get("kw", None)
|
|
if not query:
|
|
return send_file("html/find.html")
|
|
result = show()
|
|
if not hasattr(result, "__len__"):
|
|
dbg3("parse_query.show = '{}'".format(result))
|
|
return result
|
|
|
|
if len(result) > 17:
|
|
return result
|
|
result = ""
|
|
if len(query.split()) == 1:
|
|
result += "<!DOCTYPE html><style>"
|
|
result += open("styles/collapsible.css", "r").read()
|
|
result += "</style><button type='button' class='collapsible'>See Definition</button><div class='content'>"
|
|
result += define() + "</div><script>"
|
|
result += open("js/collapsible.js", "r").read() + "</script>"
|
|
dbg3("parse_query.define = '{}'".format(result))
|
|
result += search()
|
|
dbg3("parse_query.search = '{}'".format(result))
|
|
return result
|
|
|
|
|
|
@app.get("/define")
|
|
def define():
|
|
ref = request.args.get("kw", None)
|
|
if ref:
|
|
ref = ref.strip()
|
|
if not ref:
|
|
return send_file("html/dictionary.html")
|
|
with open(dictionary_json, "r") as data:
|
|
dictionary = json.load(data)
|
|
ref = ref.lower()
|
|
if not ref in dictionary.keys():
|
|
h = hunspell.HunSpell("data/kjv.dic", "data/kjv.aff")
|
|
suggestions = h.suggest(ref)
|
|
return "{} not found, try one of the following: {}".format(
|
|
ref, ", ".join(suggestions)
|
|
)
|
|
arg_view = request.args.get("view", None)
|
|
if arg_view == "plain":
|
|
response = return_dict_plain(ref, dictionary[ref])
|
|
elif arg_view == "rich":
|
|
response = return_dict_rich(ref, dictionary[ref])
|
|
else:
|
|
response = jsonify({ref: dictionary[ref]})
|
|
return response
|
|
|
|
|
|
def return_dict_plain(ref, defs):
|
|
response = ""
|
|
for e in defs:
|
|
response += e + "<br><br>"
|
|
return ref.capitalize() + "<br><br>" + response + "\n"
|
|
|
|
|
|
def return_dict_rich(ref, defs):
|
|
header = open("html/header.html", "r")
|
|
css = open("styles/human_readable.css", "r")
|
|
response_html = open("html/response.html", "r")
|
|
response = ""
|
|
for e in defs:
|
|
response += e + "<br><br>"
|
|
return (
|
|
response_html.read().format(
|
|
chapter=ref.split(":")[0], passage=ref.capitalize(), text=response
|
|
)
|
|
+ css.read()
|
|
)
|
|
|
|
|
|
@app.get("/show")
|
|
def show(kw=None, get_start_verse_id=False):
|
|
ref = request.args.get("kw", None)
|
|
if kw:
|
|
ref = kw
|
|
if ref is None:
|
|
return send_file("html/show.html")
|
|
dbg("show({})".format(ref))
|
|
refs = []
|
|
for r in ref.split(","):
|
|
r_ = ref_input_cleaning(r.strip())
|
|
if r_:
|
|
refs.append(r_)
|
|
if not refs:
|
|
return "Invalid Query"
|
|
verse_results = []
|
|
# check if the search is for multiple refs
|
|
for ref in refs:
|
|
dbg("show.reference({})".format(ref))
|
|
maybe_chapter = ref.split(":")[0][3:]
|
|
ref_chapter = ""
|
|
for maybedigit in maybe_chapter:
|
|
if maybedigit.isdigit():
|
|
ref_chapter += maybedigit
|
|
ref_verse = ref.split(":")[1]
|
|
if ref.__contains__("-"):
|
|
if ref.endswith("-"):
|
|
start_verse = ref_verse.split("-")[0]
|
|
end_verse = "500" # just get all the verses if it ends with a dash
|
|
else:
|
|
start_verse, end_verse = (
|
|
ref_verse.split("-")[0],
|
|
ref_verse.split("-")[1],
|
|
)
|
|
else:
|
|
start_verse = ref_verse
|
|
end_verse = None
|
|
end_verse_id = None
|
|
book_str = ref_input_cleaning(ref, string.ascii_letters)
|
|
ref_bookname = ref_parse_book(book_str)
|
|
ref_book_id = lookup_book_id(ref_bookname)
|
|
if not ref_book_id:
|
|
return "Invalid Query"
|
|
start_verse_id = get_verse_id(ref_book_id, ref_chapter, start_verse)
|
|
if get_start_verse_id:
|
|
return start_verse_id
|
|
if end_verse:
|
|
end_verse_id = get_verse_id(ref_book_id, ref_chapter, end_verse)
|
|
dbg2("show.start_verse_id({})".format(start_verse_id))
|
|
dbg2("show.end_verse_id({})".format(end_verse_id))
|
|
results = lookup_by_verse_id(start_verse_id, end_verse_id)
|
|
dbg3("show.results({})".format(results))
|
|
for result in results:
|
|
verse_results.append(result)
|
|
response_list = response_multi(verse_results)
|
|
arg_view = request.args.get("view", None)
|
|
if arg_view == "plain" or arg_view == "rich":
|
|
response = "<br>".join(response_list)
|
|
else:
|
|
response = jsonify(response_list)
|
|
return response
|
|
|
|
|
|
def response_dict(scripture):
|
|
# used for JSON responses
|
|
verse = {
|
|
"bookname": lookup_bookname(scripture[idx_book]),
|
|
"chapter": scripture[idx_chapter],
|
|
"verse": scripture[idx_verse],
|
|
"text": scripture[idx_text],
|
|
}
|
|
return verse
|
|
|
|
|
|
def response_text(scripture):
|
|
bookname = lookup_bookname(scripture[idx_book])
|
|
chapter = str(scripture[idx_chapter])
|
|
verse = str(scripture[idx_verse])
|
|
text = str(scripture[idx_text])
|
|
return bookname + " " + chapter + ":" + verse + " " + text + "\n"
|
|
|
|
|
|
def response_rich(scripture):
|
|
css = open("styles/human_readable.css", "r")
|
|
response_html = open("html/response.html", "r")
|
|
# (passage, text) is the html formatting arguments
|
|
bookname = lookup_bookname(scripture[idx_book])
|
|
chapter = str(scripture[idx_chapter])
|
|
verse = str(scripture[idx_verse])
|
|
text = str(scripture[idx_text])
|
|
passage = bookname + " " + chapter + ":" + verse
|
|
return (
|
|
response_html.read().format(
|
|
chapter=passage.split(":")[0], passage=passage, text=text
|
|
)
|
|
+ css.read()
|
|
)
|
|
|
|
|
|
def response_single(scripture):
|
|
dbg2("response_single({})".format(scripture))
|
|
arg_view = request.args.get("view", "json")
|
|
dbg("->requested_format = {}".format(arg_view))
|
|
if arg_view == "plain":
|
|
return response_text(scripture)
|
|
elif arg_view == "rich":
|
|
header = open("html/header.html", "r")
|
|
return header.read() + response_rich(scripture)
|
|
else:
|
|
response = response_dict(scripture)
|
|
return jsonify(response)
|
|
|
|
|
|
def response_multi(scriptures):
|
|
response = []
|
|
arg_view = request.args.get("view", "json")
|
|
dbg("search ->requested_format = {}".format(arg_view))
|
|
if arg_view == "plain":
|
|
for scripture in scriptures:
|
|
response.append(response_text(scripture))
|
|
elif arg_view == "rich":
|
|
response.append(open("html/header.html", "r").read())
|
|
for scripture in scriptures:
|
|
response.append(response_rich(scripture))
|
|
else:
|
|
for scripture in scriptures:
|
|
response.append(response_dict(scripture))
|
|
return response
|
|
|
|
|
|
@app.errorhandler(404)
|
|
def page_not_found(e):
|
|
message = {
|
|
"error": "You're lost! Isaiah 41:10 - Fear thou not; for I am with thee: be not dismayed; for I am thy God: I will strengthen thee; yea, I will help thee; yea, I will uphold thee with the right hand of my righteousness."
|
|
}
|
|
return jsonify(message)
|
|
|
|
|
|
@app.get("/")
|
|
def idx():
|
|
return send_file("html/index.html")
|
|
|
|
|
|
@app.get("/salvation")
|
|
def salvation():
|
|
return send_file("html/heaven.html")
|
|
|
|
|
|
# backwards-compatibility
|
|
@app.get("/t/random", defaults={"view": "plain"})
|
|
@app.get("/random")
|
|
def random_verse():
|
|
rand_id = random.SystemRandom().choice(verse_ids)
|
|
scripture = lookup_one_verse(rand_id)
|
|
return response_single(scripture)
|
|
|
|
|
|
# backwards-compatibility
|
|
@app.get("/t/votd", defaults={"view": "plain"})
|
|
@app.get("/votd")
|
|
def verse_of_the_day():
|
|
today = int(str(date.today()).replace("-", ""))
|
|
# this is deterministic because of today's date being used as the seed
|
|
random.seed(today)
|
|
scripture = lookup_one_verse(random.choice(verse_ids))
|
|
return response_single(scripture)
|
|
|
|
|
|
@app.get("/search")
|
|
def search():
|
|
keywords = request.args.get("kw", None)
|
|
dbg("search({})".format(keywords))
|
|
if keywords:
|
|
cleaned_keywords = search_input_cleaning(keywords)
|
|
if not cleaned_keywords:
|
|
return send_file("html/search.html")
|
|
else:
|
|
return send_file("html/search.html")
|
|
results = lookup_fts(cleaned_keywords)
|
|
if not results:
|
|
h = hunspell.HunSpell("data/kjv.dic", "data/kjv.aff")
|
|
suggestions = h.suggest(cleaned_keywords)
|
|
return "{} not found, try one of the following: {}".format(
|
|
cleaned_keywords, ", ".join(suggestions)
|
|
)
|
|
response_list = response_multi(results)
|
|
arg_view = request.args.get("view", None)
|
|
if arg_view == "plain" or arg_view == "rich":
|
|
response = "<br>".join(response_list)
|
|
else:
|
|
response = jsonify(response_list)
|
|
dbg2("Search Response: {}".format(response))
|
|
return response
|
|
|
|
|
|
@app.get("/reader")
|
|
def bible_reader():
|
|
return send_file("html/reader.html")
|
|
# We should return an index of all books with
|
|
# drop down menus of each chapter, and a search
|
|
# bar at the top for quick seeking, which can use
|
|
# show(). Each page should return a header and footer.
|
|
# header should have a navigation bar and "next/previous chapter"
|
|
# Footer should have next/previous as well.
|
|
# Maybe preliminary theming support
|
|
|
|
|
|
@app.get("/plan")
|
|
def reading_plan():
|
|
return send_file("html/reading_plan.html")
|
|
# needs 2 sets of data, books and time frame.
|
|
# should default to the entire Bible in 1 year.
|
|
# should start today() and end today()+1year
|
|
# Should return a calender with date and verse range.
|
|
|
|
|
|
@app.get("/seq")
|
|
def sequential_read(start=0, num=1, uid=None, getuid=False):
|
|
# /seq?uid=1
|
|
uid = request.args.get("uid", uid)
|
|
getuid = request.args.get("getuid", getuid)
|
|
start = request.args.get("start", start)
|
|
try:
|
|
num = int(request.args.get("num", num))
|
|
except ValueError:
|
|
return "Invalid num argument"
|
|
if not uid or not getuid:
|
|
return send_file("html/seq.html")
|
|
seq_conn = sqlite3.connect("data/seq.db")
|
|
seq_cur = seq_conn.cursor()
|
|
last_used = str(datetime.now())
|
|
num -= 1 # 0 will mean "next"
|
|
if num < 0:
|
|
return jsonify({"error":"You may only increment forward."})
|
|
|
|
if getuid:
|
|
import uuid
|
|
|
|
if start:
|
|
start = verse_ids.index(int(show(kw=start, get_start_verse_id=True)))
|
|
uid = str(uuid.uuid4())
|
|
seq_cur.execute(
|
|
"INSERT INTO reading_tracker VALUES('{}', {}, '{}')".format(
|
|
uid, start, last_used
|
|
)
|
|
)
|
|
seq_conn.commit()
|
|
dbg2("Created new UID: {}".format(uid))
|
|
return "Your new UID is: {}".format(uid)
|
|
uid = ref_input_cleaning(uid, ref_search=False)
|
|
try:
|
|
nextverse = seq_cur.execute(
|
|
"SELECT verse FROM reading_tracker WHERE uid = '{}'".format(uid)
|
|
).fetchone()[0]
|
|
dbg2("Queried UID {} on verse {}".format(uid, nextverse))
|
|
except TypeError:
|
|
dbg2("Invalid UID {}".format(uid))
|
|
return jsonify({"error":"UID Invalid or purged"})
|
|
if len(verse_ids) < (nextverse + num):
|
|
# Correct our range to go to ceiling to prevent IndexError
|
|
diff = len(verse_ids) - (nextverse + num)
|
|
num = diff - num
|
|
start_verse = verse_ids[nextverse]
|
|
end_verse = verse_ids[nextverse + num]
|
|
result_list = lookup_by_verse_id(start_verse, end_verse)
|
|
response_list = response_multi(result_list)
|
|
|
|
dbg2(
|
|
"SQL : UPDATE reading_tracker SET verse = {}, last_used = '{}' WHERE uid = '{}'".format(
|
|
nextverse + num, last_used, uid
|
|
)
|
|
)
|
|
seq_cur.execute(
|
|
"UPDATE reading_tracker SET verse = {}, last_used = '{}' WHERE uid = '{}'".format(
|
|
nextverse + num + 1, last_used, uid
|
|
)
|
|
)
|
|
seq_conn.commit()
|
|
arg_view = request.args.get("view", None)
|
|
if arg_view == "plain" or arg_view == "rich":
|
|
response = "<br>".join(response_list)
|
|
else:
|
|
response = jsonify(response_list)
|
|
|
|
return response
|