347 lines
11 KiB
Python
347 lines
11 KiB
Python
# app.py
|
|
from flask import Flask, request, jsonify, send_file
|
|
import random
|
|
from datetime import date # used for daily verse
|
|
import subprocess # use of "bible" system application for parsing and returning Bible in KJV0
|
|
import shlex # input security
|
|
import sqlite3
|
|
import string
|
|
DEBUG = 2
|
|
DEBUG_OUT = 0
|
|
|
|
"""
|
|
NOTES
|
|
- working on getting multi-search terms working right
|
|
Lookup_bookname does not like it lol.
|
|
|
|
To-do:
|
|
- Add data and function for Webster 1828 dictionary lookup
|
|
--https://github.com/DataWar/1828-dictionary
|
|
--https://github.com/mnjrupp/Android_SQLite_Dictionary_1828
|
|
--https://github.com/gapmiss/kingdom-study-tools-for-obsidian/tree/main/dictionary/
|
|
- Add data and function for Thesaurus to implement fuzzy search
|
|
--https://github.com/zaibacu/thesaurus
|
|
"""
|
|
|
|
def dbg(message):
|
|
# if DEBUG is at or above a value of one, a call from debug level one will print red
|
|
if DEBUG >= 1:
|
|
print(f'\033[91m{message}\033[0m')
|
|
def dbg2(message):
|
|
# if DEBUG is at or above a value of two, a call from debug level one will print green
|
|
if DEBUG >= 2:
|
|
print(f'\033[32m{message}\033[0m')
|
|
dbg("Debug Level 1 Enabled")
|
|
dbg2("Debug Level 2 Enabled")
|
|
|
|
kjv_db = sqlite3.connect("kjv.db")
|
|
kjv_cur = kjv_db.cursor()
|
|
verse_ids = [i[0] for i in kjv_cur.execute("SELECT id FROM t_kjv;").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):
|
|
dbg("lookup_one_verse({})".format(verse_id))
|
|
return(kjv_cur.execute("SELECT * FROM t_kjv WHERE id = {};".format(verse_id)).fetchone())
|
|
|
|
def lookup_bookname(book_id):
|
|
dbg2("lookup_bookname({})".format(book_id))
|
|
result = kjv_cur.execute("SELECT n FROM key_english WHERE b = {}".format(book_id)).fetchone()[0]
|
|
dbg("lookup_bookname: {}".format(result))
|
|
return result
|
|
|
|
|
|
def lookup_contains(kw):
|
|
results = kjv_cur.execute("SELECT * FROM t_kjv WHERE t LIKE '%{}%';".format(kw)).fetchall()
|
|
dbg("lookup_contains({}) {} results".format(kw,len(results)))
|
|
return results
|
|
|
|
def lookup_contains_exact(kw):
|
|
results = kjv_cur.execute("SELECT * FROM t_kjv WHERE t LIKE '%{}%';".format(kw)).fetchall()
|
|
dbg("lookup_contains({}) {} results".format(kw,len(results)))
|
|
return results
|
|
|
|
def response_dict(scripture):
|
|
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)
|
|
|
|
def response_rich(scripture):
|
|
css = open('human_readable.css', 'r')
|
|
response_html = open('response.html', 'r')
|
|
# passage, text
|
|
|
|
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(passage = passage, text = text) + css.read())
|
|
|
|
def response_single(scripture):
|
|
dbg2("response_single({})".format(scripture))
|
|
arg_view = request.args.get("view", None)
|
|
dbg("->requested_format = {}".format(arg_view))
|
|
if arg_view == "plain":
|
|
return(response_text(scripture))
|
|
elif arg_view == "rich":
|
|
return(response_rich(scripture))
|
|
else:
|
|
response = response_dict(scripture)
|
|
return jsonify(response)
|
|
|
|
def response_multi(scriptures):
|
|
dbg2("response_multi({})".format(scriptures))
|
|
response = []
|
|
arg_view = request.args.get("view", None)
|
|
dbg("search ->requested_format = {}".format(arg_view))
|
|
|
|
if arg_view == "plain":
|
|
for scripture in scriptures:
|
|
dbg2("for scripture in scriptures content: {}".format(scripture))
|
|
response.append(response_text(scripture))
|
|
elif arg_view == "rich":
|
|
for scripture in scriptures:
|
|
dbg2("for scripture in scriptures content: {}".format(scripture))
|
|
response.append(response_rich(scripture))
|
|
else:
|
|
for scripture in scriptures:
|
|
dbg2("for scripture in scriptures content: {}".format(scripture))
|
|
response.append(response_dict(scripture))
|
|
|
|
return(response)
|
|
|
|
|
|
def thesarus(word):
|
|
return word
|
|
def dictionary(word):
|
|
return word
|
|
|
|
|
|
@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("index.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))
|
|
|
|
# splits by delimiter then checks for any special characters
|
|
# if special characters are found, the query is rejected
|
|
def clean_keywords(kwds):
|
|
kwds = kwds.split(',')
|
|
for kwd in kwds:
|
|
if not kwd.isalpha():
|
|
return False
|
|
dbg("clean_keywords = ({})".format(kwds))
|
|
return kwds
|
|
|
|
|
|
def search_and(cleaned_keywords):
|
|
results = []
|
|
for keyword in cleaned_keywords:
|
|
dbg("search->for keyword in database({})".format(keyword))
|
|
#This is groups of results per word. Must check between groups.
|
|
results.append(lookup_contains(keyword))
|
|
return (results)
|
|
|
|
def search_any(cleaned_keywords):
|
|
results = []
|
|
for keyword in cleaned_keywords:
|
|
dbg("search->for keyword in database({})".format(keyword))
|
|
for result in lookup_contains(keyword):
|
|
results.append(result)
|
|
dbg("==> search_any: {} results".format(len(results)))
|
|
return(results)
|
|
|
|
|
|
@app.get("/search")
|
|
def search():
|
|
keywords = request.args.get("kw", None)
|
|
dbg("search({})".format(keywords))
|
|
if keywords:
|
|
cleaned_keywords = clean_keywords(keywords)
|
|
if not clean_keywords:
|
|
return ("Invalid Query: Special Characters")
|
|
else:
|
|
return ("No Query")
|
|
|
|
if request.args.get("operator",None) == "and":
|
|
results = search_and(cleaned_keywords)
|
|
else:
|
|
results = search_any(cleaned_keywords)
|
|
|
|
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("/qwerty")
|
|
def test():
|
|
style = css.read()
|
|
return (style + "Hello! Testing!")
|
|
|
|
# plain
|
|
@app.get("/<passage>")
|
|
def passage_json(passage):
|
|
try:
|
|
command = "bible -f {}".format(shlex.quote(passage))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
return jsonify(result)
|
|
except Exception as e:
|
|
return jsonify(str(e))
|
|
|
|
# pretty
|
|
@app.get("/p/<passage>")
|
|
def passage_text(passage):
|
|
try:
|
|
command = "bible {}".format(shlex.quote(passage))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
return result
|
|
except Exception as e:
|
|
return str(e)
|
|
|
|
|
|
#search
|
|
@app.get("/s/<keyword>")
|
|
def search_json(keyword):
|
|
try:
|
|
command = "bible -f ??{}".format(shlex.quote(keyword))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
if result.contains("??word"):
|
|
raise Exception("Not found.")
|
|
result = result.split()
|
|
result = result[7:]
|
|
return jsonify(result)
|
|
except Exception as e:
|
|
return jsonify(str(e))
|
|
|
|
#search
|
|
@app.get("/sp/<keyword>")
|
|
def search_text(keyword):
|
|
try:
|
|
command = "bible -f ??{}".format(shlex.quote(keyword))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
if result.contains("??word"):
|
|
raise Exception("Not found.")
|
|
result = result.split()
|
|
result = result[7:]
|
|
result = '<br>'.join(map(str, result))
|
|
return result
|
|
except Exception as e:
|
|
return str(e)
|
|
|
|
#search text json
|
|
@app.get("/sl/<keyword>")
|
|
def search_json_return(keyword):
|
|
try:
|
|
command = "bible -f ??{}".format(shlex.quote(keyword))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
if result.contains("??word"):
|
|
raise Exception("Not found.")
|
|
result = result.split()
|
|
result = result[7:]
|
|
complete_result = []
|
|
for verse in result:
|
|
complete_result.append(passage_text(verse))
|
|
return jsonify(complete_result)
|
|
except Exception as e:
|
|
return str(e)
|
|
|
|
#search pretty
|
|
@app.get("/spl/<keyword>")
|
|
def search_text_return(keyword):
|
|
try:
|
|
command = "bible -f ??{}".format(shlex.quote(keyword))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
if result.contains("??word"):
|
|
raise Exception("Not found.")
|
|
result = result.split()
|
|
result = result[7:]
|
|
complete_result = []
|
|
for verse in result:
|
|
complete_result.append(passage_text(verse))
|
|
result = '<br>'.join(map(str, complete_result))
|
|
return result
|
|
except Exception as e:
|
|
return str(e)
|
|
|
|
#search pretty multiple
|
|
@app.get("/splm/<keywords>")
|
|
def search_text_return_multiple(keywords):
|
|
if len(keywords.split('&')) > 1:
|
|
pass
|
|
try:
|
|
command = "bible -f ??{}".format(shlex.quote(keyword))
|
|
result = str(subprocess.check_output(command, shell=True), "utf-8")
|
|
if len(result) == 0:
|
|
raise Exception("You have entered an incorrect syntax or your query returned no results.")
|
|
if result.contains("??word"):
|
|
raise Exception("Not found.")
|
|
result = result.split()
|
|
result = result[7:]
|
|
complete_result = []
|
|
for verse in result:
|
|
complete_result.append(passage_text(verse))
|
|
result = '<br>'.join(map(str, complete_result))
|
|
return result
|
|
except Exception as e:
|
|
return str(e)
|