import logging
import os
import subprocess
try:
result = subprocess.run(['bash', 'install.sh'], check=True)
except subprocess.CalledProcessError as e:
print(f"The install script failed with return code {e.returncode}")
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
import gradio as gr
import torah
import bible
import quran
import hindu
import tripitaka
from utils import number_to_ordinal_word, custom_normalize, date_to_words, translate_date_to_words
from gematria import calculate_gematria, strip_diacritics
import pandas as pd
from deep_translator import GoogleTranslator
from gradio_calendar import Calendar
from datetime import datetime, timedelta
import math
import json
import re
import sqlite3
from collections import defaultdict
from typing import List, Tuple
# import rich # Removed rich
# from fuzzywuzzy import fuzz # Removed fuzzywuzzy
import calendar
import translation_utils
import hashlib
import copy
from collections import Counter
translation_utils.create_translation_table()
# Create a translator instance *once* globally
translator = GoogleTranslator(source='auto', target='auto')
LANGUAGES_SUPPORTED = translator.get_supported_languages(as_dict=True)
LANGUAGE_CODE_MAP = LANGUAGES_SUPPORTED # Use deep_translator's mapping directly
# --- Constants ---
DATABASE_FILE = 'gematria.db'
MAX_PHRASE_LENGTH_LIMIT = 20
ELS_CACHE_DB = "els_cache.db"
DATABASE_TIMEOUT = 60
# --- ELS Cache Functions ---
def create_els_cache_table():
if not os.path.exists(ELS_CACHE_DB):
with sqlite3.connect(ELS_CACHE_DB) as conn:
conn.execute('''
CREATE TABLE IF NOT EXISTS els_cache (
query_hash TEXT PRIMARY KEY,
function_name TEXT,
args TEXT,
kwargs TEXT,
results TEXT
)
''')
# --- Database Initialization ---
def initialize_database():
global conn
conn = sqlite3.connect(DATABASE_FILE)
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS results (
gematria_sum INTEGER,
words TEXT,
translation TEXT,
book TEXT,
chapter INTEGER,
verse INTEGER,
phrase_length INTEGER,
word_position TEXT,
PRIMARY KEY (gematria_sum, words, book, chapter, verse, word_position)
)
''')
cursor.execute('''
CREATE INDEX IF NOT EXISTS idx_results_gematria
ON results (gematria_sum)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS processed_books (
book TEXT PRIMARY KEY,
max_phrase_length INTEGER
)
''')
conn.commit()
# --- Initialize Database ---
initialize_database()
# --- ELS Cache Functions ---
def create_els_cache_table():
with sqlite3.connect(ELS_CACHE_DB) as conn:
try:
conn.execute('''
CREATE TABLE IF NOT EXISTS els_cache (
query_hash TEXT PRIMARY KEY,
function_name TEXT,
args TEXT,
kwargs TEXT,
results TEXT
)
''')
except sqlite3.OperationalError as e:
logger.error(f"Error creating table: {e}")
def get_query_hash(func, args, kwargs):
key = (func.__name__, args, kwargs)
return hashlib.sha256(json.dumps(key).encode()).hexdigest()
def cached_process_json_files(func, *args, **kwargs):
# Create a dictionary to store the parameters
params = {
"function": f"{func.__module__}.{func.__name__}"
}
# Add the positional arguments with their names
arg_names = func.__code__.co_varnames[:func.__code__.co_argcount]
for name, value in zip(arg_names, args):
params[name] = value
# Add the keyword arguments
for name, value in kwargs.items():
params[name] = value
# Convert the parameters to a JSON string
params_json = json.dumps(params)
# Use the parameters JSON string to generate the query hash
query_hash = get_query_hash(func, params_json, "")
# Ensure the table exists before any operations
create_els_cache_table()
try:
with sqlite3.connect(ELS_CACHE_DB, timeout=DATABASE_TIMEOUT) as conn:
cursor = conn.cursor()
cursor.execute(
"SELECT results FROM els_cache WHERE query_hash = ?", (query_hash,))
result = cursor.fetchone()
if result:
logger.info(f"Cache hit for query: {query_hash}")
return json.loads(result[0])
except sqlite3.Error as e:
logger.error(f"Database error checking cache: {e}")
logger.info(f"Cache miss for query: {query_hash}")
results = func(*args, **kwargs)
try:
with sqlite3.connect(ELS_CACHE_DB, timeout=DATABASE_TIMEOUT) as conn:
cursor = conn.cursor()
cursor.execute(
"INSERT INTO els_cache (query_hash, function_name, args, kwargs, results) VALUES (?, ?, ?, ?, ?)",
(query_hash, params["function"], params_json, json.dumps({}), json.dumps(results)))
conn.commit()
except sqlite3.Error as e:
logger.error(f"Database error caching results: {e}")
return results
# --- Helper Functions (from Network app.py) ---
def flatten_text(text: List) -> str:
if isinstance(text, list):
return " ".join(flatten_text(item) if isinstance(item, list) else item for item in text)
return text
def search_gematria_in_db(gematria_sum: int, max_words: int) -> List[Tuple[str, str, int, int, int, str]]:
global conn
with sqlite3.connect(DATABASE_FILE) as conn:
cursor = conn.cursor()
cursor.execute('''
SELECT words, book, chapter, verse, phrase_length, word_position
FROM results
WHERE gematria_sum = ? AND phrase_length <= ?
''', (gematria_sum, max_words))
results = cursor.fetchall()
return results
def get_most_frequent_phrase(results):
phrase_counts = defaultdict(int)
for words, book, chapter, verse, phrase_length, word_position in results:
phrase_counts[words] += 1
most_frequent_phrase = max(phrase_counts, key=phrase_counts.get) if phrase_counts else None
return most_frequent_phrase
# --- Functions from BOS app.py ---
def create_language_dropdown(label, default_value='English', show_label=True):
return gr.Dropdown(
choices=list(LANGUAGE_CODE_MAP.keys()),
label=label,
value=default_value,
show_label=show_label
)
def calculate_gematria_sum(text, date_words):
if text or date_words:
combined_input = f"{text} {date_words}"
logger.info(f"searching for input: {combined_input}")
numbers = re.findall(r'\d+', combined_input)
text_without_numbers = re.sub(r'\d+', '', combined_input)
number_sum = sum(int(number) for number in numbers)
text_gematria = calculate_gematria(strip_diacritics(text_without_numbers))
total_sum = text_gematria + number_sum
return total_sum
else:
return None
def perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk,
include_torah, include_bible, include_quran, include_hindu, include_tripitaka):
if step == 0 or rounds_combination == "0,0":
return None
results = {}
length = 0
selected_language_long = tlang
tlang = LANGUAGES_SUPPORTED.get(selected_language_long)
if tlang is None:
tlang = "en"
logger.warning(
f"Unsupported language selected: {selected_language_long}. Defaulting to English (en).")
if include_torah:
logger.debug(
f"Arguments for Torah: {(1, 39, step, rounds_combination, length, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)}")
results["Torah"] = cached_process_json_files(torah.process_json_files, 1, 39, step, rounds_combination, length,
tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
else:
results["Torah"] = []
if include_bible:
results["Bible"] = cached_process_json_files(bible.process_json_files, 40, 66, step, rounds_combination,
length,
tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
else:
results["Bible"] = []
if include_quran:
results["Quran"] = cached_process_json_files(quran.process_json_files, 1, 114, step, rounds_combination,
length,
tlang, strip_spaces, strip_in_braces, strip_diacritics_chk)
else:
results["Quran"] = []
if include_hindu:
results["Rig Veda"] = cached_process_json_files(
hindu.process_json_files, 1, 10, step, rounds_combination, length, tlang, False, strip_in_braces,
strip_diacritics_chk)
else:
results["Rig Veda"] = []
if include_tripitaka:
results["Tripitaka"] = cached_process_json_files(
tripitaka.process_json_files, 1, 52, step, rounds_combination, length, tlang, strip_spaces,
strip_in_braces, strip_diacritics_chk)
else:
results["Tripitaka"] = []
return results
def add_24h_projection(results_dict):
for book_name, results in results_dict.items():
num_results = len(results)
if num_results > 0:
time_interval = timedelta(minutes=24 * 60 / num_results)
current_time = datetime.min.time()
for i in range(num_results):
next_time = (datetime.combine(datetime.min, current_time) + time_interval).time()
time_range_str = f"{current_time.strftime('%H:%M')}-{next_time.strftime('%H:%M')}"
results[i]['24h Projection'] = time_range_str
current_time = next_time
return results_dict
def add_monthly_projection(results_dict, selected_date):
if selected_date is None:
return results_dict
for book_name, results in results_dict.items():
num_results = len(results)
if num_results > 0:
days_in_month = calendar.monthrange(selected_date.year, selected_date.month)[1]
total_seconds = (days_in_month - 1) * 24 * 3600
seconds_interval = total_seconds / num_results
start_datetime = datetime(selected_date.year, selected_date.month, 1)
current_datetime = start_datetime
for i in range(num_results):
next_datetime = current_datetime + timedelta(seconds=seconds_interval)
current_date = current_datetime.date()
next_date = next_datetime.date()
date_range_str = f"{current_date.strftime('%h %d')} - {next_date.strftime('%h %d')}"
results[i]['Monthly Projection'] = date_range_str
current_datetime = next_datetime
current_date = next_datetime.date()
return results_dict
def add_yearly_projection(results_dict, selected_date):
if selected_date is None:
return results_dict
for book_name, results in results_dict.items():
num_results = len(results)
if num_results > 0:
days_in_year = 366 if calendar.isleap(selected_date.year) else 365
total_seconds = (days_in_year - 1) * 24 * 3600
seconds_interval = total_seconds / num_results
start_datetime = datetime(selected_date.year, 1, 1)
current_datetime = start_datetime
for i in range(num_results):
next_datetime = current_datetime + timedelta(seconds=seconds_interval)
current_date = current_datetime.date()
next_date = next_datetime.date()
date_range_str = f"{current_date.strftime('%b %d')} - {next_date.strftime('%b %d')}"
results[i]['Yearly Projection'] = date_range_str
current_datetime = next_datetime
return results_dict
def sort_results(results):
def parse_time(time_str):
try:
hours, minutes = map(int, time_str.split(':'))
return hours * 60 + minutes
except ValueError:
return 24 * 60
return sorted(results, key=lambda x: (
parse_time(x.get('24h Projection', '23:59').split('-')[0]),
parse_time(x.get('24h Projection', '23:59').split('-')[1])
))
def extract_rounds_combinations():
"""Extracts unique rounds combinations from the database."""
combinations = set()
try:
with sqlite3.connect(ELS_CACHE_DB) as conn:
cursor = conn.cursor()
cursor.execute("SELECT args FROM els_cache")
all_args = cursor.fetchall()
for args_tuple in all_args:
args_str = args_tuple[0]
try:
args_json = json.loads(args_str)
if 'rounds' in args_json:
combinations.add(args_json['rounds'])
except json.JSONDecodeError:
logger.error(f"Could not decode JSON for args: {args_str}")
except sqlite3.Error as e:
logger.error(f"Database error: {e}")
logger.info(f"Found unique rounds combinations: {combinations}")
return ["All"] + sorted(list(combinations))
def update_rounds_dropdown():
new_choices = extract_rounds_combinations()
return new_choices
def perform_gematria_calculation_for_date_range(start_date, end_date):
logger.debug(f"Calculating date gematria for range: {start_date} - {end_date}")
results = {}
delta = timedelta(days=1)
current_date = start_date
while current_date <= end_date:
date_string = current_date.strftime("%Y-%m-%d")
date_words = date_to_words(date_string)
date_gematria = calculate_gematria_sum(date_words, "") # Angepasst, um der Funktion calculate_gematria_sum zu entsprechen
results[date_string] = {
"date_words": date_words,
"date_gematria": date_gematria,
}
current_date += delta
logger.debug(f"Finished calculating date gematria.")
return results
def find_matching_dates(date_gematrias, names, search_journal_sum):
logger.debug(f"Searching for matches with journal sum: {search_journal_sum}")
matching_dates = {}
for name in names:
name_gematria = calculate_gematria_sum(name, "") # Angepasst, um der Funktion calculate_gematria_sum zu entsprechen
target_date_gematria = search_journal_sum - name_gematria if name_gematria is not None else None
logger.debug(f"Name: {name}, Gematria: {name_gematria}, Target Date Gematria: {target_date_gematria}")
if target_date_gematria is not None:
for date_str, date_data in date_gematrias.items():
if date_data["date_gematria"] == target_date_gematria:
if name not in matching_dates:
matching_dates[name] = []
matching_dates[name].append(date_str)
logger.debug(f"Matches for {name}: {matching_dates.get(name, [])}")
return matching_dates
def find_shared_journal_sums(date_gematrias, names):
"""Finds shared journal sums and formats output with names and dates together."""
logger.debug("Calculating shared journal sums...")
shared_sums = {}
name_gematrias = {name: calculate_gematria_sum(name, "") for name in names}
for date_str, date_data in date_gematrias.items():
date_gematria = date_data["date_gematria"]
for name, name_gematria in name_gematrias.items():
journal_sum = date_gematria + name_gematria
journal_sum_str = str(journal_sum) # Konvertiere den Schlüssel (journal_sum) in einen String
if journal_sum_str not in shared_sums:
shared_sums[journal_sum_str] = {}
if name not in shared_sums[journal_sum_str]:
shared_sums[journal_sum_str][name] = []
shared_sums[journal_sum_str][name].append(date_str)
# Filter out sums not shared by at least two names and format output
result = {}
for journal_sum_str, data in shared_sums.items():
if len(data) >= 2:
result[journal_sum_str] = {}
for name, dates in data.items():
result[journal_sum_str][name] = dates
logger.debug(f"Shared Journal Sums: {result}")
return result
def calculate_and_find_dates(start_date, end_date, names_input, search_journal_sum, find_shared=False):
names = [n.strip() for n in names_input.split("\n") if n.strip()]
date_gematrias = perform_gematria_calculation_for_date_range(start_date, end_date)
if find_shared:
shared_sums = find_shared_journal_sums(date_gematrias, names)
return None, shared_sums
else:
matching_dates = find_matching_dates(date_gematrias, names, int(search_journal_sum))
return matching_dates, None
# --- Main Gradio App ---
with gr.Blocks() as app:
with gr.Tab("ELS Search"):
with gr.Column():
with gr.Row():
tlang = create_language_dropdown("Target Language for Result Translation", default_value='english')
selected_date = Calendar(type="datetime", label="Date to investigate (optional)",
info="Pick a date from the calendar")
use_day = gr.Checkbox(label="Use Day", info="Check to include day in search", value=True)
use_month = gr.Checkbox(label="Use Month", info="Check to include month in search", value=True)
use_year = gr.Checkbox(label="Use Year", info="Check to include year in search", value=True)
date_language_input = create_language_dropdown(
"Language of the person/topic (optional) (Date Word Language)", default_value='english')
with gr.Row():
gematria_text = gr.Textbox(label="Name and/or Topic (required)",
value="Albert Einstein Mileva Marity-Einstein")
date_words_output = gr.Textbox(label="Date in Words Translated (optional)")
gematria_result = gr.Number(label="Journal Sum")
# with gr.Row():
with gr.Row():
step = gr.Number(label="Jump Width (Steps) for ELS")
float_step = gr.Number(visible=False, value=1)
half_step_btn = gr.Button("Steps / 2")
double_step_btn = gr.Button("Steps * 2")
with gr.Column():
round_x = gr.Number(label="Round (1)", value=1)
round_y = gr.Number(label="Round (2)", value=-1)
rounds_combination = gr.Textbox(label="Combined Rounds", value="1,-1")
with gr.Row():
include_torah_chk = gr.Checkbox(label="Include Torah", value=True)
include_bible_chk = gr.Checkbox(label="Include Bible", value=True)
include_quran_chk = gr.Checkbox(label="Include Quran", value=True)
include_hindu_chk = gr.Checkbox(label="Include Rigveda", value=False)
include_tripitaka_chk = gr.Checkbox(label="Include Tripitaka", value=False)
strip_spaces = gr.Checkbox(label="Strip Spaces from Books", value=True)
strip_in_braces = gr.Checkbox(label="Strip Text in Braces from Books", value=True)
strip_diacritics_chk = gr.Checkbox(label="Strip Diacritics from Books", value=True)
translate_btn = gr.Button("Search with ELS")
# --- Output Components ---
markdown_output = gr.Dataframe(label="ELS Results")
most_frequent_phrase_output = gr.Textbox(label="Most Frequent Phrase in Network Search")
json_output = gr.JSON(label="JSON Output")
with gr.Tab("Cache Database Search"):
with gr.Column():
with gr.Row():
main_book_filter = gr.Dropdown(label="Filter by Main Book",
choices=["All", "Torah", "Bible", "Quran", "Rig Veda", "Tripitaka"],
value="Torah")
# Keine choices hier, nur das Label und den Initialwert
rounds_filter = gr.Dropdown(label="Filter by Rounds", allow_custom_value=True, value="1,-1")
with gr.Row():
search_type = gr.Radio(label="Search by",
choices=["Text in result_text", "Gematria Sum in results"],
value="Text in result_text")
with gr.Row():
search_mode = gr.Radio(label="Search Mode",
choices=["Exact Search", "Contains Word"],
value="Contains Word")
with gr.Row():
search_term = gr.Textbox(label="Search Term", visible=True)
gematria_sum_search = gr.Number(label="Gematria Sum", visible=False)
with gr.Row():
search_db_btn = gr.Button("Search Cache Database")
with gr.Row():
cache_search_results = gr.JSON(label="Cache Search Results")
def update_search_components(search_type):
if search_type == "Text in result_text":
return gr.Textbox.update(visible=True), gr.Number.update(visible=False)
else:
return gr.Textbox.update(visible=False), gr.Number.update(visible=True)
def search_cache_database(search_type, search_term, gematria_sum_search, main_book_filter, rounds_filter, search_mode):
"""Searches the cache database based on the selected filters and search term."""
results = []
search_term = strip_diacritics(search_term)
if main_book_filter == "All" and rounds_filter == "All" and not search_term and not gematria_sum_search:
return results
try:
with sqlite3.connect(ELS_CACHE_DB) as conn:
cursor = conn.cursor()
if search_type == "Text in result_text":
# Optimization: If only main_book_filter is selected, don't perform a full search
if main_book_filter != "All" and rounds_filter == "All" and not search_term:
return results
cursor.execute("SELECT * FROM els_cache")
all_results = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]
for row in all_results:
row_dict = dict(zip(columns, row))
args_dict = json.loads(row_dict['args'])
function_name = row_dict['function_name']
# Function name filtering
include_result = False
if main_book_filter == "All":
include_result = True
elif main_book_filter == "Torah" and function_name == "torah.process_json_files":
include_result = True
elif main_book_filter == "Bible" and function_name == "bible.process_json_files":
include_result = True
elif main_book_filter == "Quran" and function_name == "quran.process_json_files":
include_result = True
elif main_book_filter == "Rig Veda" and function_name == "hindu.process_json_files":
include_result = True
elif main_book_filter == "Tripitaka" and function_name == "tripitaka.process_json_files":
include_result = True
if not include_result:
continue
# Rounds filtering
if rounds_filter != "All" and args_dict.get('rounds') != rounds_filter:
continue
try:
results_json = json.loads(row_dict['results'])
for result_entry in results_json:
if 'result_text' in result_entry:
if search_mode == "Exact Search" and search_term == result_entry['result_text']:
entry = {
'function_name': function_name,
'step': args_dict.get('step'),
'rounds': args_dict.get('rounds'),
'result': result_entry
}
results.append(entry)
elif search_mode == "Contains Word" and search_term in result_entry['result_text']:
entry = {
'function_name': function_name,
'step': args_dict.get('step'),
'rounds': args_dict.get('rounds'),
'result': result_entry
}
results.append(entry)
except (json.JSONDecodeError, TypeError) as e:
logger.error(f"Error processing row: {e}")
continue
elif search_type == "Gematria Sum in results":
# Optimization: If only main_book_filter is selected, don't perform a full search
if main_book_filter != "All" and rounds_filter == "All" and not gematria_sum_search:
return results
if not isinstance(gematria_sum_search, (int, float)):
return results
cursor.execute("SELECT * FROM els_cache")
all_results = cursor.fetchall()
columns = [desc[0] for desc in cursor.description]
for row in all_results:
row_dict = dict(zip(columns, row))
args_dict = json.loads(row_dict['args'])
function_name = row_dict['function_name']
# Function name filtering
include_result = False
if main_book_filter == "All":
include_result = True
elif main_book_filter == "Torah" and function_name == "torah.process_json_files":
include_result = True
elif main_book_filter == "Bible" and function_name == "bible.process_json_files":
include_result = True
elif main_book_filter == "Quran" and function_name == "quran.process_json_files":
include_result = True
elif main_book_filter == "Rig Veda" and function_name == "hindu.process_json_files":
include_result = True
elif main_book_filter == "Tripitaka" and function_name == "tripitaka.process_json_files":
include_result = True
if not include_result:
continue
# Rounds filtering
if rounds_filter != "All" and args_dict.get('rounds') != rounds_filter:
continue
try:
results_json = json.loads(row_dict['results'])
for result_entry in results_json:
if 'result_sum' in result_entry and result_entry[
'result_sum'] == gematria_sum_search:
entry = {
'function_name': function_name,
'step': args_dict.get('step'),
'rounds': args_dict.get('rounds'),
'result': result_entry
}
results.append(entry)
except (json.JSONDecodeError, TypeError) as e:
logger.error(f"Error processing row: {e}")
continue
# Sort results by gematria sum
results.sort(
key=lambda x: x['result']['result_sum'] if 'result' in x and 'result_sum' in x['result'] else 0)
return results
except sqlite3.Error as e:
logger.error(f"Database error: {e}")
return []
def update_search_components(search_type):
"""Updates the visibility of the search term and gematria sum input fields."""
if search_type == "Text in result_text":
return {"visible": True, "__type__": "update"}, {"visible": False, "__type__": "update"}
else:
return {"visible": False, "__type__": "update"}, {"visible": True, "__type__": "update"}
with gr.Tab("Date Range Synchronicity + Journal-sum Search"):
with gr.Row():
start_date_jr = Calendar(type="datetime", label="Start Date")
end_date_jr = Calendar(type="datetime", label="End Date")
with gr.Row():
names_input_jr = gr.Textbox(label="Names (one per line)", lines=5)
search_sum_jr = gr.Number(label="Search Journal Sum", precision=0)
with gr.Row():
calculate_btn_jr = gr.Button("Search Journal Sum")
shared_sums_btn_jr = gr.Button("Find Shared Journal Sums")
matching_dates_output_jr = gr.JSON(label="Matching Dates")
shared_sums_output_jr = gr.JSON(label="Shared Journal Sums")
calculate_btn_jr.click(
lambda start_date, end_date, names_input, search_sum: calculate_and_find_dates(
start_date, end_date, names_input, search_sum, find_shared=False),
inputs=[start_date_jr, end_date_jr, names_input_jr, search_sum_jr],
outputs=[matching_dates_output_jr, shared_sums_output_jr]
)
shared_sums_btn_jr.click(
lambda start_date, end_date, names_input: calculate_and_find_dates(
start_date, end_date, names_input, 0, find_shared=True),
inputs=[start_date_jr, end_date_jr, names_input_jr],
outputs=[matching_dates_output_jr, shared_sums_output_jr]
)
with gr.Tab("Date Range ELS Journal Search"):
with gr.Row():
start_date_els = Calendar(type="datetime", label="Start Date")
end_date_els = Calendar(type="datetime", label="End Date")
with gr.Row():
names_input_els = gr.Textbox(label="Names (one per line)", lines=5)
with gr.Row():
search_type_els = gr.Radio(
label="Search by",
choices=["Text in result_text", "Gematria Sum in results"],
value="Text in result_text"
)
with gr.Row():
search_mode_els = gr.Radio(
label="Search Mode",
choices=["Exact Search", "Contains Word"],
value="Contains Word"
)
with gr.Row():
search_term_els = gr.Textbox(label="Search Term", visible=True)
gematria_sum_search_els = gr.Number(label="Gematria Sum", visible=False)
with gr.Row():
include_torah_chk_els = gr.Checkbox(label="Include Torah", value=True)
include_bible_chk_els = gr.Checkbox(label="Include Bible", value=True)
include_quran_chk_els = gr.Checkbox(label="Include Quran", value=True)
include_hindu_chk_els = gr.Checkbox(label="Include Rigveda", value=False)
include_tripitaka_chk_els = gr.Checkbox(label="Include Tripitaka", value=False)
with gr.Row():
translate_results_chk_els = gr.Checkbox(label="Translate Results to English", value=False)
with gr.Row():
sub_oscillation_search_chk_els = gr.Checkbox(label="Search in Sub-Oscillations", value=False) # Neue Checkbox
sub_oscillation_level_els = gr.Number(label="Sub-Oscillation Level (0 = off)", precision=0, value=1)
with gr.Row():
perform_search_btn_els = gr.Button("Perform Search")
filtered_results_output_els = gr.JSON(label="Filtered Results")
# Funktionen zur Aktualisierung der Sichtbarkeit der Sucheingabefelder
def update_search_components_els(search_type):
if search_type == "Text in result_text":
return gr.Textbox(visible=True), gr.Number(visible=False)
else:
return gr.Textbox(visible=False), gr.Number(visible=True)
search_type_els.change(
fn=update_search_components_els,
inputs=[search_type_els],
outputs=[search_term_els, gematria_sum_search_els]
)
def perform_els_search_for_gematria_sum(
gematria_sum,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka
):
"""
Calls your actual ELS search function, returning a dict like:
{
"Torah": [ { "result_sum": ..., "result_text": ..., "source_language": ...}, ...],
"Bible": [...],
...
}
"""
return perform_els_search(
step=gematria_sum,
rounds_combination="1,-0.5,0.5,-1",
tlang="english",
strip_spaces=True,
strip_in_braces=True,
strip_diacritics_chk=True,
include_torah=include_torah,
include_bible=include_bible,
include_quran=include_quran,
include_hindu=include_hindu,
include_tripitaka=include_tripitaka
)
def perform_sub_oscillation_search(
base_results_list,
initial_gematria_sum,
level,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka
):
"""
Recursively populates 'subresults' for each base entry, up to the specified level.
base_results_list: A list of dicts, each shaped like:
{
"book": "Torah",
"result": {
"result_sum": ...,
"result_text": ...
},
"subresults": []
}
initial_gematria_sum: The base sum from day+name (or from prior recursion).
level: how many sub-levels we still want to descend.
include_XXX: booleans for controlling which texts to include.
"""
if level <= 0:
return base_results_list
for base_entry in base_results_list:
parent_sum = base_entry["result"]["result_sum"]
combined_sum = initial_gematria_sum + parent_sum
# Next-level search
sub_search_results = perform_els_search_for_gematria_sum(
gematria_sum=combined_sum,
include_torah=include_torah,
include_bible=include_bible,
include_quran=include_quran,
include_hindu=include_hindu,
include_tripitaka=include_tripitaka
)
# Build child entries
child_entries = []
for book_name, res_list in sub_search_results.items():
for one_res in res_list:
child_entries.append({
"book": book_name,
"result": one_res,
"subresults": []
})
# Attach to subresults
base_entry["subresults"].extend(child_entries)
# Recurse deeper
perform_sub_oscillation_search(
base_entry["subresults"],
initial_gematria_sum,
level - 1,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka
)
return base_results_list
def matches_criteria(item, search_type, search_term, gematria_sum_search, search_mode):
"""
Checks if a single item (a dict with 'result_text', 'result_sum', etc.)
matches the user’s chosen filter criteria.
item shape example:
{
"book": "Torah",
"result": {
"result_text": "foo bar",
"result_sum": 1234,
...
},
"subresults": [ ... ]
}
"""
result_text = item["result"].get("result_text", "")
result_sum = item["result"].get("result_sum", None)
if search_type == "Text in result_text":
if search_mode == "Exact Search":
return (result_text == search_term)
else: # "Contains Word"
return (search_term in result_text)
else:
# search_type == "Gematria Sum in results"
return (result_sum == gematria_sum_search)
def prune_tree_by_search_criteria(results_list, search_type, search_term, gematria_sum_search, search_mode):
"""
Recursively filters a list of items so that:
- An item is included if it directly matches the search criteria,
OR if any of its child subresults match (in which case we keep
the item *and* the matching children).
- This preserves parent chain for matching subresults.
returns a new, pruned list of items with the same nested structure,
but only containing the branches that match or lead to a match.
"""
pruned_list = []
for item in results_list:
# Recurse into subresults first
pruned_sub = prune_tree_by_search_criteria(
item["subresults"],
search_type,
search_term,
gematria_sum_search,
search_mode
)
does_item_match = matches_criteria(item, search_type, search_term, gematria_sum_search, search_mode)
# If the item itself matches OR any child matches
if does_item_match or len(pruned_sub) > 0:
# Make a copy of the item so we don't destroy the original
new_item = copy.deepcopy(item)
# Overwrite subresults with the pruned version
new_item["subresults"] = pruned_sub
pruned_list.append(new_item)
return pruned_list
def translate_subresults_recursive(subresults_list):
"""
Recursively translates the 'result_text' of each item in subresults_list.
We only visit items that remain in the filtered results.
"""
for sub_item in subresults_list:
text = sub_item["result"].get("result_text", "")
source_lang = sub_item["result"].get("source_language", "auto")
if text:
translated_text = translation_utils.get_translation(text, "en", source_lang)[0]
sub_item["result"]["translated_text"] = translated_text
# Recurse into deeper subresults
if sub_item["subresults"]:
translate_subresults_recursive(sub_item["subresults"])
def perform_date_range_els_search(
start_date,
end_date,
names_input,
search_type,
search_term,
gematria_sum_search,
search_mode,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka,
translate_results,
sub_oscillation_search,
sub_oscillation_level
):
"""
- Builds a fully nested sub-oscillation structure if requested.
- Then prunes it so only matching items remain (plus parents).
- Finally, optionally translates the pruned items if requested.
- Returns the filtered (and optionally translated) structure.
"""
# 1) Compute gematria sums for all dates in the chosen range
names = [n.strip() for n in names_input.split("\n") if n.strip()]
date_gematrias = perform_gematria_calculation_for_date_range(start_date, end_date)
all_filtered_results = []
# 2) Loop over each date
for date_str, date_data in date_gematrias.items():
for name in names:
# base sum: day gematria + name gematria
name_gem = calculate_gematria_sum(name, "")
initial_gem = date_data["date_gematria"] + name_gem
date_words = date_data["date_words"]
search_path_basic = f"{name} {date_words}"
# 3) Do the base ELS search (this is the top-level results)
base_results = perform_els_search_for_gematria_sum(
gematria_sum=initial_gem,
include_torah=include_torah,
include_bible=include_bible,
include_quran=include_quran,
include_hindu=include_hindu,
include_tripitaka=include_tripitaka
)
# 4) Convert "base_results" into a uniform nested format
# shaped like { "0": {"book":..., "results": [ {...}, ... ]}, ... }
formatted_base_results = {}
idx_counter = 0
for book_name, book_res_list in base_results.items():
if book_res_list:
formatted_base_results[str(idx_counter)] = {
"book": book_name,
"results": []
}
for res in book_res_list:
formatted_base_results[str(idx_counter)]["results"].append({
"book": book_name,
"result": res,
"subresults": []
})
idx_counter += 1
# 5) Flatten out for sub-osc recursion
base_results_list = []
for val in formatted_base_results.values():
base_results_list.extend(val["results"])
# 6) If sub-oscillation is requested, build deeper levels
if sub_oscillation_search and sub_oscillation_level > 0 and base_results_list:
perform_sub_oscillation_search(
base_results_list,
initial_gem,
sub_oscillation_level,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka
)
# 7) Now we prune (filter) the results according to the user’s search criteria
# For each "book" block, we filter the "results" array
pruned_base_results = {}
for key, block in formatted_base_results.items():
original_list = block["results"] # each is {book, result, subresults}
filtered_list = prune_tree_by_search_criteria(
original_list,
search_type,
search_term,
gematria_sum_search,
search_mode
)
# Keep only if we got something back
if filtered_list:
pruned_base_results[key] = {
"book": block["book"],
"results": filtered_list
}
# If there’s nothing left after filtering, skip adding
if not pruned_base_results:
continue
# 8) Build the final item for this date+name, with pruned results
final_item = {
"date": date_str,
"name": name,
"search_path_basic": search_path_basic,
"basic_gematria": initial_gem,
"basic_results": pruned_base_results
}
# 9) If translation is requested, only translate the pruned results
if translate_results:
# Recursively translate only the items in pruned_base_results
for block_key, block_val in final_item["basic_results"].items():
for entry in block_val["results"]:
txt = entry["result"].get("result_text", "")
src_lang = entry["result"].get("source_language", "auto")
if txt:
trans = translation_utils.get_translation(txt, "en", src_lang)[0]
entry["result"]["translated_text"] = trans
# And go deeper into subresults
if entry["subresults"]:
translate_subresults_recursive(entry["subresults"])
# 10) Add this final, fully filtered (and possibly translated) item
all_filtered_results.append(final_item)
# Return the fully processed set of results
return all_filtered_results
def remove_duplicates(dict_list):
"""
If you need to remove duplicates at any stage, you can call this,
but it's optional if your data doesn't require deduping.
"""
seen = set()
unique_list = []
for item in dict_list:
item_id = repr(item)
if item_id not in seen:
seen.add(item_id)
unique_list.append(item)
return unique_list
perform_search_btn_els.click(
perform_date_range_els_search,
inputs=[
start_date_els,
end_date_els,
names_input_els,
search_type_els,
search_term_els,
gematria_sum_search_els,
search_mode_els,
include_torah_chk_els,
include_bible_chk_els,
include_quran_chk_els,
include_hindu_chk_els,
include_tripitaka_chk_els,
translate_results_chk_els,
sub_oscillation_search_chk_els,
sub_oscillation_level_els
],
outputs=[filtered_results_output_els]
)
with gr.Tab("ELS Journal Gematria-sum Synchronicity search"):
with gr.Row():
start_date_comp = Calendar(type="datetime", label="Start Date")
end_date_comp = Calendar(type="datetime", label="End Date")
with gr.Row():
names_input_comp = gr.Textbox(label="Names (one per line)", lines=5)
with gr.Row():
sub_oscillation_level_comp = gr.Number(label="Sub-Oscillation Level", precision=0, value=0)
with gr.Row():
include_torah_chk_comp = gr.Checkbox(label="Include Torah", value=True)
include_bible_chk_comp = gr.Checkbox(label="Include Bible", value=True)
include_quran_chk_comp = gr.Checkbox(label="Include Quran", value=True)
include_hindu_chk_comp = gr.Checkbox(label="Include Rigveda", value=False)
include_tripitaka_chk_comp = gr.Checkbox(label="Include Tripitaka", value=False)
with gr.Row():
translate_results_chk_comp = gr.Checkbox(label="Translate Results to English", value=False)
with gr.Row():
common_gematria_results = gr.JSON(label="Common Gematria Results")
with gr.Row():
perform_search_btn_comp = gr.Button("Perform Search")
def perform_comprehensive_els_search(
start_date,
end_date,
names_input,
sub_oscillation_level,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka,
translate_results
):
names = [n.strip() for n in names_input.split("\n") if n.strip()]
date_gematrias = perform_gematria_calculation_for_date_range(start_date, end_date)
all_results_by_date = {}
for date_str, date_data in date_gematrias.items():
all_results_by_date[date_str] = {}
for name in names:
name_gem = calculate_gematria_sum(name, "")
initial_gem = date_data["date_gematria"] + name_gem
base_results_list = []
base_results = perform_els_search_for_gematria_sum(
gematria_sum=initial_gem,
include_torah=include_torah,
include_bible=include_bible,
include_quran=include_quran,
include_hindu=include_hindu,
include_tripitaka=include_tripitaka
)
for book_name, res_list in base_results.items():
for one_res in res_list:
if not isinstance(one_res, dict) or "result_sum" not in one_res:
print(f"Warning: Invalid result format for {name} on {date_str}: {one_res}")
continue
base_results_list.append({
"book": book_name,
"result": one_res,
"subresults": []
})
if sub_oscillation_level > 0 and base_results_list:
perform_sub_oscillation_search(
base_results_list,
initial_gem,
sub_oscillation_level,
include_torah,
include_bible,
include_quran,
include_hindu,
include_tripitaka
)
all_results_by_date[date_str][name] = base_results_list
common_results = {}
for date_str, name_results in all_results_by_date.items():
common_results[date_str] = {}
sums_by_name = {}
all_sums_count = Counter()
for name, results in name_results.items():
sums_by_name[name] = set()
count_sums_recursive(results, all_sums_count)
extract_sums_recursive(results, sums_by_name[name])
ordered_common_sums = [item for item, count in all_sums_count.most_common() if all(item in sums_by_name[n] for n in sums_by_name)]
for common_sum in ordered_common_sums:
common_results[date_str][str(common_sum)] = {}
for name, results in name_results.items():
matching_items = []
for item in results:
if find_results_by_sum([item], common_sum):
item_copy = copy.deepcopy(item)
if translate_results:
translate_recursive(item_copy)
item_copy["subresults"] = find_results_by_sum(item.get("subresults", []), common_sum)
if translate_results:
for sub_item in item_copy["subresults"]:
translate_recursive(sub_item)
matching_items.append(item_copy)
if matching_items:
common_results[date_str][str(common_sum)][name] = matching_items
return common_results
def find_results_by_sum(results, target_sum):
matches = []
if isinstance(results, list):
for item in results:
matches.extend(find_results_by_sum(item, target_sum))
elif isinstance(results, dict):
if "result" in results and isinstance(results["result"], dict) and "result_sum" in results["result"]:
try:
result_sum = int(results["result"]["result_sum"])
if result_sum == target_sum:
matches.append(results)
except (TypeError, ValueError) as e:
print(f"Error comparing result_sum: {e}, Data: {results}")
if "subresults" in results:
matches.extend(find_results_by_sum(results["subresults"], target_sum))
return matches
def extract_sums_recursive(data, sums_set):
if isinstance(data, list):
for item in data:
extract_sums_recursive(item, sums_set)
elif isinstance(data, dict):
if "result" in data and isinstance(data["result"], dict) and "result_sum" in data["result"]:
try:
result_sum = int(data["result"]["result_sum"])
sums_set.add(result_sum)
except (TypeError, ValueError) as e:
print(f"Error extracting result_sum: {e}, Data: {data}")
if "subresults" in data:
extract_sums_recursive(data["subresults"], sums_set)
def count_sums_recursive(data, sums_counter):
if isinstance(data, list):
for item in data:
count_sums_recursive(item, sums_counter)
elif isinstance(data, dict):
if "result" in data and isinstance(data["result"], dict) and "result_sum" in data["result"]:
try:
result_sum = int(data["result"]["result_sum"])
sums_counter[result_sum] += 1
except (TypeError, ValueError) as e:
print(f"Error counting result_sum: {e}, Data: {data}")
if "subresults" in data:
count_sums_recursive(data["subresults"], sums_counter)
def translate_recursive(item):
if "result" in item and isinstance(item["result"], dict) and "result_text" in item["result"]:
text = item["result"].get("result_text", "")
source_lang = item["result"].get("source_language", "auto")
if text:
translated_text = translation_utils.get_translation(text, "en", source_lang)[0]
item["result"]["translated_text"] = translated_text
if "subresults" in item and isinstance(item["subresults"], list):
for sub in item["subresults"]:
translate_recursive(sub)
perform_search_btn_comp.click(
perform_comprehensive_els_search,
inputs=[
start_date_comp,
end_date_comp,
names_input_comp,
sub_oscillation_level_comp,
include_torah_chk_comp,
include_bible_chk_comp,
include_quran_chk_comp,
include_hindu_chk_comp,
include_tripitaka_chk_comp,
translate_results_chk_comp
],
outputs=[common_gematria_results]
)
# --- Event Handlers ---
search_type.change(
fn=update_search_components,
inputs=[search_type],
outputs=[search_term, gematria_sum_search]
)
search_db_btn.click(
fn=search_cache_database,
inputs=[search_type, search_term, gematria_sum_search, main_book_filter, rounds_filter, search_mode],
outputs=cache_search_results
)
def update_rounds_choices():
return gr.update(choices=extract_rounds_combinations()) # gr.update, nicht gr.Dropdown.update
app.load(fn=update_rounds_choices, inputs=None, outputs=rounds_filter)
main_book_filter.change(
fn=update_rounds_choices,
inputs=None, # No input needed here
outputs=rounds_filter
)
# rest of the handlers
def update_date_words(selected_date, date_language_input, use_day, use_month, use_year):
if selected_date is None:
return ""
if not use_year and not use_month and not use_day:
return translate_date_to_words(selected_date, date_language_input)
year = selected_date.year if use_year else None
month = selected_date.month if use_month else None
day = selected_date.day if use_day else None
if year is not None and month is not None and day is not None:
date_obj = selected_date
elif year is not None and month is not None:
date_obj = str(f"{year}-{month}")
elif year is not None:
date_obj = str(f"{year}")
else: # Return empty string if no date components are selected
return ""
date_in_words = date_to_words(date_obj)
translator = GoogleTranslator(source='auto', target=date_language_input)
translated_date_words = translator.translate(date_in_words)
return custom_normalize(translated_date_words)
def update_journal_sum(gematria_text, date_words_output):
sum_value = calculate_gematria_sum(gematria_text, date_words_output)
return sum_value, sum_value, sum_value
def update_rounds_combination(round_x, round_y):
return f"{int(round_x)},{int(round_y)}"
def update_step_half(float_step):
new_step = math.ceil(float_step / 2)
return new_step, float_step / 2
def update_step_double(float_step):
new_step = math.ceil(float_step * 2)
return new_step, float_step * 2
def find_closest_phrase(target_phrase, phrases):
best_match = None
best_score = 0
logging.debug(f"Target phrase for similarity search: {target_phrase}")
for phrase, _, _, _, _, _ in phrases:
word_length_diff = abs(len(target_phrase.split()) - len(phrase.split()))
similarity_score = fuzz.ratio(target_phrase, phrase)
combined_score = similarity_score - word_length_diff
logging.debug(f"Comparing with phrase: {phrase}")
logging.debug(
f"Word Length Difference: {word_length_diff}, Similarity Score: {similarity_score}, Combined Score: {combined_score}")
if combined_score > best_score:
best_score = combined_score
best_match = phrase
logging.debug(f"Closest phrase found: {best_match} with score: {best_score}")
return best_match
def perform_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk,
include_torah, include_bible, include_quran, include_hindu, include_tripitaka, gematria_text,
date_words_output, selected_date):
els_results = perform_els_search(step, rounds_combination, tlang, strip_spaces, strip_in_braces,
strip_diacritics_chk, include_torah, include_bible, include_quran,
include_hindu,
include_tripitaka)
most_frequent_phrases = {}
combined_and_sorted_results = []
for book_name, book_results in els_results.items():
if book_results:
most_frequent_phrases[book_name] = ""
for result in book_results:
try:
gematria_sum = calculate_gematria(result['result_text'])
max_words = len(result['result_text'].split())
matching_phrases = search_gematria_in_db(gematria_sum, max_words)
max_words_limit = 20
while not matching_phrases and max_words < max_words_limit:
max_words += 1
matching_phrases = search_gematria_in_db(gematria_sum, max_words)
if matching_phrases:
most_frequent_phrase = get_most_frequent_phrase(matching_phrases)
most_frequent_phrases[book_name] = most_frequent_phrase
else:
# closest_phrase = find_closest_phrase(result['result_text'],
# search_gematria_in_db(gematria_sum, max_words_limit)) # Removed fuzzywuzzy
most_frequent_phrases[
book_name] = "" # closest_phrase or ""
result['Most Frequent Phrase'] = most_frequent_phrases[book_name]
if 'book' in result:
if isinstance(result['book'], int):
result['book'] = f"{book_name} {result['book']}."
combined_and_sorted_results.append(result)
except KeyError as e:
print(f"DEBUG: KeyError - Key '{e.args[0]}' not found in result. Skipping this result.")
continue
selected_language_long = tlang
tlang_short = LANGUAGES_SUPPORTED.get(selected_language_long)
if tlang_short is None:
tlang_short = "en"
logger.warning(f"Unsupported language selected: {selected_language_long}. Defaulting to English (en).")
phrases_to_translate = []
phrases_source_langs = []
results_to_translate = []
results_source_langs = []
for result in combined_and_sorted_results:
phrases_to_translate.append(result.get('Most Frequent Phrase', ''))
phrases_source_langs.append("he")
results_to_translate.append(result.get('result_text', ''))
results_source_langs.append(result.get("source_language", "auto"))
translated_phrases = translation_utils.batch_translate(phrases_to_translate, tlang_short,
phrases_source_langs)
translated_result_texts = translation_utils.batch_translate(results_to_translate, tlang_short,
results_source_langs)
for i, result in enumerate(combined_and_sorted_results):
result['translated_text'] = translated_result_texts.get(results_to_translate[i], None)
result['Translated Most Frequent Phrase'] = translated_phrases.get(phrases_to_translate[i], None)
updated_els_results = add_24h_projection(els_results)
updated_els_results = add_monthly_projection(updated_els_results, selected_date)
updated_els_results = add_yearly_projection(updated_els_results, selected_date)
combined_and_sorted_results = []
for book_results in updated_els_results.values():
combined_and_sorted_results.extend(book_results)
combined_and_sorted_results = sort_results(combined_and_sorted_results)
df = pd.DataFrame(combined_and_sorted_results)
df.index = range(1, len(df) + 1)
df.reset_index(inplace=True)
df.rename(columns={'index': 'Result Number'}, inplace=True)
for i, result in enumerate(combined_and_sorted_results):
result['Result Number'] = i + 1
search_config = {
"step": step,
"rounds_combination": rounds_combination,
"target_language": tlang,
"strip_spaces": strip_spaces,
"strip_in_braces": strip_in_braces,
"strip_diacritics": strip_diacritics_chk,
"include_torah": include_torah,
"include_bible": include_bible,
"include_quran": include_quran,
"include_hindu": include_hindu,
"include_tripitaka": include_tripitaka,
"gematria_text": gematria_text,
"date_words": date_words_output
}
output_data = {
"search_configuration": search_config,
"results": combined_and_sorted_results
}
json_data = output_data
combined_most_frequent = "\n".join(
f"{book}: {phrase}" for book, phrase in most_frequent_phrases.items())
return df, combined_most_frequent, json_data
# --- Event Triggers ---
round_x.change(update_rounds_combination, inputs=[round_x, round_y], outputs=rounds_combination)
round_y.change(update_rounds_combination, inputs=[round_x, round_y], outputs=rounds_combination)
selected_date.change(update_date_words, inputs=[selected_date, date_language_input, use_day, use_month, use_year],
outputs=[date_words_output])
date_language_input.change(update_date_words,
inputs=[selected_date, date_language_input, use_day, use_month, use_year],
outputs=[date_words_output])
gematria_text.change(update_journal_sum, inputs=[gematria_text, date_words_output],
outputs=[gematria_result, step, float_step])
date_words_output.change(update_journal_sum, inputs=[gematria_text, date_words_output],
outputs=[gematria_result, step, float_step])
half_step_btn.click(update_step_half, inputs=[float_step], outputs=[step, float_step])
double_step_btn.click(update_step_double, inputs=[float_step], outputs=[step, float_step])
translate_btn.click(
perform_search,
inputs=[step, rounds_combination, tlang, strip_spaces, strip_in_braces, strip_diacritics_chk, include_torah_chk,
include_bible_chk, include_quran_chk, include_hindu_chk, include_tripitaka_chk, gematria_text,
date_words_output, selected_date],
outputs=[markdown_output, most_frequent_phrase_output, json_output]
)
app.load(
update_date_words,
inputs=[selected_date, date_language_input, use_day, use_month, use_year],
outputs=[date_words_output]
)
use_day.change(
update_date_words,
inputs=[selected_date, date_language_input, use_day, use_month, use_year],
outputs=[date_words_output]
)
use_month.change(
update_date_words,
inputs=[selected_date, date_language_input, use_day, use_month, use_year],
outputs=[date_words_output]
)
use_year.change(
update_date_words,
inputs=[selected_date, date_language_input, use_day, use_month, use_year],
outputs=[date_words_output]
)
def checkbox_behavior(use_day_value, use_month_value):
if use_day_value:
return True, True
return use_month_value, True
use_day.change(checkbox_behavior, inputs=[use_day, use_month], outputs=[use_month, use_year])
use_month.change(checkbox_behavior, inputs=[use_day, use_month], outputs=[use_month, use_year])
if __name__ == "__main__":
app.launch(share=False)