\
+ \
+ \
+ '
+ elif columns == 1:
+ body_string += '' + f'\
+ \
+ \
+ '
+ body_string += ''
+ return body_string
+
+def create_table(body_string,parts,t_type,columns,header=''):
+ body_string = create_style(body_string,columns)
+ body_string += f'| {header} | '
+ columns = parts[list(parts.keys())[0]]
+ for col in columns:
+ body_string += f'{col} | '
+ body_string += "
|---|
"
+ for row in parts:
+ body_string += ''
+ if t_type == 'noun':
+ body_string += f'| {row[:3]}. | '
+ elif t_type == 'conj':
+ body_string += f'{row[:3]} | '
+ else:
+ body_string += f'{row} | '
+ for col in parts[row]:
+ body_string += f'{parts[row][col]} | '
+ body_string += '
'
+ body_string += '
'
+ return body_string
+
+def print_tables(tables_list,language):
+ if language == 'Ancient Greek':
+ tables_greek_ext.print_tables(tables_list)
+ elif language == 'Latin':
+ tables_latin_ext.print_tables(tables_list)
+ elif language == 'Old English':
+ tables_oe_ext.print_tables(tables_list)
+ print("\n**************************\n\nFlashcards printed to file\n\n**************************\n")
+'''
+
+#import parser_shell, word_print_edit, edit_dictionary, edit_entry
+def add_definition(language):
+
+ while True:
+ change_path('dumps sorted')
+ wiki_dump = parser_shell.load_dump(language)
+ combo_word = parser_shell.choose_from_alpha(wiki_dump,[],language)
+ if combo_word == 'end' or combo_word == 'return to top' or combo_word == 'back':
+ return None
+ else:
+ if len(combo_word['entries']) > 1:
+ selection = word_print_edit.select_entry(combo_word['entries'],"Choose the definition you want to use:")
+ else:
+ selection = 0
+ number = edit_entry.select_definition(combo_word['entries'][selection],"Choose the line you want to use:")
+ definition = combo_word['entries'][selection]['defs'][number]['gloss']
+ if selection == None:
+ return None
+ else:
+ return definition
+'''
\ No newline at end of file
diff --git a/tables_greek_ext.py b/tables_greek_ext.py
new file mode 100644
index 0000000..6c0bc0a
--- /dev/null
+++ b/tables_greek_ext.py
@@ -0,0 +1,1316 @@
+
+from bs4 import BeautifulSoup
+import tables
+import html_x
+from load_dict import change_path
+from get_selection import get_selection
+from copy import deepcopy, copy
+import random
+import sys
+import glob, json
+
+'''
+{'title': capio
+'search word':
+'definition #':
+'POS': verb
+'definition': 'to take'
+'principle' : capio, capere, capi ,captum
+'parts':[mood][tense]etc..."capere"
+'forms':[{'form':'capere','article':'','tense':'present',etc...}}
+] }
+
+'''
+
+DEBUG = True
+import inspect
+
+def debug_print(message):
+ line_number = inspect.currentframe().f_back.f_lineno
+ if DEBUG:
+ print(f"[Line {line_number}] - {message}")
+
+def new_template(heading="",handle="",definition="",POS=""):
+ template = {}
+ while True:
+ x = 'POS'
+ options = {'0':f"\nEnter choose template {x} ('0' to go back)\n==================================\n",
+ '1':"'1'> noun\n",'2':"'2'> verb\n",
+ '00':"'00' to quit\n"}
+ user_input = get_selection(options)
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ else:
+ template[x] = 'noun' if user_input == '1' else 'verb'
+ if template[x] == 'noun':
+ x = 'gender'
+ options = {'0':f"\nEnter choose template {x} ('0' to go back)\n==================================\n",
+ '1':"'1'> (m)\n",
+ '2':"'2'> (f)\n",
+ '3':"'3'> (m or f)\n",
+ '4':"'4'> (n)\n",
+ '5':"'5'> (m,f,n)\n",
+ '6':"'6'> (m/f,n)\n",
+ '7':"'7'> (m/f/n)\n",
+ '00':"'00' to quit\n"}
+ user_input = get_selection(options)
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ else:
+ template[x] = options[user_input][options[user_input].find("("):].strip("\n")
+ print("Proper noun? ('Y' for yes, any other key for no)")
+ user_input = input(": ")
+ template['proper'] = True if user_input.upper() == 'Y' else False
+ while True:
+ x = 'title'
+ if heading == "":
+ print(f"Enter template {x} ('0' to go back)")
+ user_input = input(": ")
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ else:
+ template[x] = user_input
+ else:
+ template[x] = heading
+ while True:
+ x = 'search word'
+ if handle == "":
+ print(f"Enter template {x} ('0' to go back '00' to quit)")
+ user_input = input(": ")
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ else:
+ template[x] = tables.replace_greek_ii(user_input)
+ else:
+ template[x] = handle
+ while True:
+ print("Enter definition number ('0' if unspecified)")
+ try:
+ template['defno'] = int(input(": "))
+ except:
+ print("Invalid entry")
+ continue
+
+ template = get_forms(template)
+ x = 'definition'
+ print(f"Enter template {x} ('0' to go back '00' to quit)")
+ user_input = input(": ")
+ if user_input == '0':
+ continue
+ elif user_input == '00':
+ return
+ else:
+ template[x] = user_input
+ print(template)
+ return template
+
+def edit_template(template):
+ while True:
+ options = {'1':f"\nTemplate \"{template['title']}\" options:\n==================================\n'1' change definition\n",
+ '2':"'2' to display forms\n",
+ '3':"'3' to re-do forms\n",
+ '4':"'4' to delete\n",
+ '0':"'0' to go back\n"}
+ user_input = get_selection(options)
+
+ if user_input == '1':
+ print(f"Current definition: {template['definition']}")
+ user_input = input("Enter new definition ('0' to cancel): ")
+ if user_input == '0':
+ continue
+ else:
+ template['definition'] == user_input
+ elif user_input == '2':
+ print(template['principal'])
+ print_parts(template['parts'])
+ input("\n\nPress Enter to continue\n")
+ elif user_input == '3':
+ template = get_forms(template)
+ elif user_input == '4':
+ del template
+ return
+ elif user_input == '0':
+ return
+
+def print_parts(chunk,string='',outer_key=''):
+ if string != '' or outer_key != '':
+ string += " " + outer_key
+ if type(chunk) == dict:
+ for inner_key in chunk:
+ print_parts(chunk[inner_key],string,inner_key)
+ else:
+ if chunk != '---':
+ final_str = f"{string.lstrip():_<70}" + chunk
+ print(final_str)
+
+def get_forms(template):
+ if template['POS'] == 'noun':
+ if template['gender'] == '(multi)':
+ while True:
+ print(f"{template['title']} (m,f,n)>1 or (m/f,n)>2?")
+ user_input = input(": ")
+ if user_input == '1':
+ template['gender'] = '(m,f,n)'
+ break
+ elif user_input == '2':
+ template['gender'] = '(m/f,n)'
+ break
+ else:
+ print("Invalid selection")
+ template['parts'] = retreive_noun_forms(template)
+ if template['gender'] == '(m,f,n)':
+ parts = template['parts']['Nominative']['Singular']
+ template['principal'] = ", ".join([x for x in parts.values()])
+ template['forms'] = inside_out_multi_noun(template['parts'])
+ elif template['gender'] == '(m/f,n)':
+ print(template['parts']['Nominative']['Singular'])
+ template['parts'] = fix_two_ending(template['parts'])
+ parts = template['parts']['Nominative']['Singular']
+ template['principal'] = ", ".join([y for x,y in parts.items() if x != 'Feminine'])
+ template['forms'] = inside_out_multi_noun(template['parts'])
+ else:
+ parts = template['parts']['Nominative']['Singular']
+ nom = parts['article'] + " " + parts['form']
+ parts = template['parts']['Genitive']['Singular']
+ gen = parts['article'] + " " + parts['form']
+ template['principal'] = nom + ", " + gen
+ template['forms'] = inside_out_noun(template['parts'])
+ elif template['POS'] == 'verb':
+ template['parts'] = retreive_verb_forms(template)
+ result = assign_principle_parts({},template['parts'])
+ result = [y['Principal Part'] for y in result['parts'].values()]
+ template['principal'] = ", ".join(result)
+ template['forms'] = inside_out_verb(template['parts'])
+ return template
+
+def redo(templates):
+ for template in templates:
+ template = get_forms(template)
+ return templates
+
+def fix_two_ending(parts):
+ for case in parts:
+ for number in parts[case]:
+ print(f"{case} {number} Masculine = {parts[case][number]['Masculine']}")
+ parts[case][number]["Feminine"] = parts[case][number]["Masculine"]
+ print(f"{case} {number} Feminine now = {parts[case][number]['Feminine']}")
+ print(parts)
+ return parts
+
+
+def nu_movable(x):
+ wo_nu = x[:x.find("(")]
+ letter = x[x.find("(")+1:-1]
+ if len(letter) > 1:
+ return [wo_nu]
+ with_nu = wo_nu + letter
+ return [wo_nu,with_nu]
+
+def perfectMiddleSubjuctive(part):
+ parts = part.split()
+ if len(parts) == 2:
+ parts[1] = parts[1].split("/")
+ if len(parts[1]) == 2:
+ new_parts = [parts[0] + " " + parts[1][0], parts[0] + " " + parts[1][1]]
+ return new_parts
+ return parts
+
+def inside_out_multi_noun(parts):
+ forms = []
+ print(parts)
+ for case in parts:
+ for number in parts[case]:
+ for gender in parts[case][number]:
+ if parts[case][number][gender] != "—":
+ if "," in parts[case][number][gender]:
+ for x in parts[case][number][gender].split(","):
+ if x.strip()[-1] == ')':
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ elif "/" in parts[case][number][gender]:
+ for x in parts[case][number][gender].split("/"):
+ if x.strip()[-1] == ')':
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ else:
+ print(f"{case} {number} {gender} = {parts[case][number][gender]}")
+ if parts[case][number][gender][-1] == ")":
+ for x in nu_movable(parts[case][number][gender]):
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[case][number][gender]}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ return forms
+
+def inside_out_noun(parts):
+ forms = []
+ for case in parts:
+ for number in parts[case]:
+ if parts[case][number]['form'] != "—":
+ if "," in parts[case][number]['form']:
+ for x in parts[case][number]['form'].split(","):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['article'] = parts[case][number]['article']
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['article'] = parts[case][number]['article']
+ forms.append(deepcopy(form))
+ elif "/" in parts[case][number]['form']:
+ for x in parts[case][number]['form'].split("/"):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['article'] = parts[case][number]['article']
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['article'] = parts[case][number]['article']
+ forms.append(deepcopy(form))
+ else:
+ if parts[case][number]['form'][-1] == ")":
+ for x in nu_movable(parts[case][number]['form']):
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['article'] = parts[case][number]['article']
+ forms.append(deepcopy(form))
+ form = {'form':parts[case][number]['form']}
+ form['case'] = case
+ form['number'] = number
+ form['article'] = parts[case][number]['article']
+ forms.append(deepcopy(form))
+ return forms
+
+def inside_out_verb(parts):
+ forms = []
+ for tense in parts:
+ for voice in parts[tense]:
+ for mood in parts[tense][voice]:
+ if mood == 'Infinitive':
+ if parts[tense][voice][mood] != "---":
+ if "," in parts[tense][voice][mood]:
+ for x in parts[tense][voice][mood].split(","):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ elif "/" in parts[tense][voice][mood]:
+ for x in parts[tense][voice][mood].split("/"):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ if parts[tense][voice][mood][-1] == ")":
+ for x in nu_movable(parts[tense][voice][mood]):
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[tense][voice][mood]}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ elif mood == 'Participle':
+ for gender in parts[tense][voice][mood]:
+ if parts[tense][voice][mood][gender] != "---":
+ if "," in parts[tense][voice][mood][gender]:
+ for x in parts[tense][voice][mood][gender].split(","):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['gender'] = gender
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['gender'] = gender
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ elif "/" in parts[tense][voice][mood][gender]:
+ for x in parts[tense][voice][mood][gender].split("/"):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['gender'] = gender
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['gender'] = gender
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ if parts[tense][voice][mood][gender][-1] == ")":
+ for x in nu_movable(parts[tense][voice][mood][gender]):
+ form = {'form':x.strip()}
+ form['gender'] = gender
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[tense][voice][mood][gender]}
+ form['gender'] = gender
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ for person in parts[tense][voice][mood]:
+ if parts[tense][voice][mood][person] != "---":
+ if "," in parts[tense][voice][mood][person]:
+ for x in parts[tense][voice][mood][person].split(","):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ elif "/" in parts[tense][voice][mood][person]:
+ perfmidsubj_flag = False
+ for x in parts[tense][voice][mood][person].split("/"):
+ if x in ['ὦ','ᾖς','ᾖ','ἦτον','εἴην','εἴης','εἴη','εἴητον','εἶτον','εἰήτην','εἴτην','ὦμεν','ἦτε','ὦσῐ','ὦσῐ(ν)','εἴημεν','εἶμεν','εἴητε','εἶτε','εἴησᾰν','εἶεν']:
+ perfmidsubj_flag = True
+ if perfmidsubj_flag:
+ for x in perfectMiddleSubjuctive(parts[tense][voice][mood][person]):
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ else:
+ for x in parts[tense][voice][mood][person].split("/"):
+ if x.strip()[-1] == ")":
+ for y in nu_movable(x):
+ form = {'form':y.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ else:
+ if parts[tense][voice][mood][person][-1] == ")":
+ for x in nu_movable(parts[tense][voice][mood][person]):
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[tense][voice][mood][person]}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ return forms
+
+
+
+
+def auto_parts(parts,rapid_fire=False):
+ if not rapid_fire:
+ print("Enter look up word")
+ user_input = input(": ")
+ else:
+ if " " in parts:
+ user_input = parts[:parts.find(" ")+1]
+ else:
+ user_input = parts
+ user_input = tables.replace_greek_ii(user_input)
+ print(user_input)
+ #try:
+ result = retreive_verb_forms({'search word':user_input,'title':''})#'defno':0})
+ result = assign_principle_parts(result,result)
+ result = [y['Principal Part'] for y in result['parts'].values()]
+ result = ", ".join(result)
+ while True:
+ print("Does this look right ('1' to except '0' to discard)?")
+ print(result)
+ user_input = input(": ")
+ if user_input == '1':
+ return result
+ elif user_input == '0':
+ return parts
+ else:
+ print("Invalid entry")
+ #except:
+ # print("Something went wrong")
+ return parts
+
+def assign_principle_parts(table_info,tenses,template=None):
+ table_info['parts'] = {}
+ # 1
+
+ part = copy(tenses['Present']['Active']['Indicative']['1st Person Singular'])
+ if part == "---":
+ part = copy(tenses['Present']['Middle/Passive']['Indicative']['1st Person Singular'])
+ if part == "---":
+ part = copy(tenses['Present']['Middle']['Indicative']['1st Person Singular'])
+
+ table_info['parts'].update({'Present':{'Principal Part':part}})
+
+ # 2
+ part = copy(tenses['Future']['Active']['Indicative']['1st Person Singular'])
+ if part == "---":
+ part = copy(tenses['Future']['Middle']['Indicative']['1st Person Singular'])
+
+ table_info['parts'].update({'Future':{'Principal Part':part}})
+
+ part = copy(tenses['Perfect']['Middle/Passive']['Indicative']['1st Person Singular'])
+ if part == '---':
+ part = copy(tenses['Perfect']['Middle']['Indicative']['1st Person Singular'])
+
+ table_info['parts'].update(
+ # 3
+ {'Aorist Act.':{'Principal Part':tenses['Aorist']['Active']['Indicative']['1st Person Singular']},\
+ # 4
+ 'Perfect Act.':{'Principal Part':tenses['Perfect']['Active']['Indicative']['1st Person Singular']},\
+ # 5
+ 'Perf. M./P.':{'Principal Part':part},\
+ # 6
+ 'Aorist Pas.':{'Principal Part':tenses['Aorist']['Passive']['Indicative']['1st Person Singular']}})
+ if template:
+ table_info['title'] = f"Principal Parts: {template['title']}"
+ return table_info
+
+def count_indent(a):
+ return len(a) - len(a.lstrip())
+
+def retreive_verb_forms(template):
+ if 'defno' in template:
+ defno = template['defno']
+ else:
+ defno = 0
+ html_doc = tables.get_html(template['search word'])
+ if html_doc == None:
+ return
+ soup = BeautifulSoup(html_doc, 'html.parser')
+ page_list = soup.prettify().split('\n')
+ if template['title'] == 'εἰμῐ́':
+ print("exception detected")
+ exception = True
+ else:
+ exception = False
+ page_list = clean_page_list(page_list,exception)
+
+ tenses = {"Present":'','Imperfect':'','Future':'','Aorist':'','Perfect':'','Pluperfect':''}
+ voices = {"Active":'',"Middle/Passive":'',"Middle":'','Passive':''}
+ moods = {'Indicative':[],'Subjunctive':[],'Optative':[],'Imperative':[],"Infinitive":[],"Participle":[]}
+ mood_list = ['Indicative','Subjunctive','Optative','Imperative']
+ persons = {'1st Person Singular':'---','2nd Person Singular':'---','3rd Person Singular':'---','2nd Person Dual':'---','3rd Person Dual':'---','1st Person Plural':'---','2nd Person Plural':'---','3rd Person Plural':'---'}
+ genders = {'Masculine':'---','Feminine':'---','Neuter':'---'}
+ codec = {'m':'Masculine','f':'Feminine','n':'Neuter'}
+
+ for tense in tenses:
+ tenses[tense] = deepcopy(voices)
+ for voice in tenses[tense]:
+ tenses[tense][voice] = deepcopy(moods)
+ for mood in tenses[tense][voice]:
+ if mood in mood_list:
+ tenses[tense][voice][mood] = deepcopy(persons)
+ elif mood == 'Participle':
+ tenses[tense][voice][mood] = deepcopy(genders)
+ elif mood == 'Infinitive':
+ tenses[tense][voice][mood] = '---'
+ tense = False
+ mood = False
+ voice = False
+
+ indent = 0
+ uncontracted = {}
+ unc_flag = False
+ counter = 0
+
+
+ def build(uncontracted,tense,voice,mood):
+ if tense not in uncontracted:
+ uncontracted[tense] = {}
+ if voice not in uncontracted[tense]:
+ uncontracted[tense][voice] = {}
+ if mood not in uncontracted[tense][voice]:
+ uncontracted[tense][voice][mood] = {}
+ if mood in mood_list:
+ tenses[tense][voice][mood] = deepcopy(persons)
+ elif mood == 'Participle':
+ tenses[tense][voice][mood] = deepcopy(genders)
+ elif mood == 'Infinitive':
+ tenses[tense][voice][mood] = '---'
+
+
+
+ for i in range(len(page_list)):
+ if counter < defno:
+ if page_list[i].strip(": ").title() in tenses:
+ if not indent:
+ indent = count_indent(page_list[i])
+ if count_indent(page_list[i]) < indent - 2:
+ indent = 0
+ counter += 1
+ else:
+ if count_indent(page_list[i]) < indent - 2:
+ if counter < defno:
+ indent = 0
+ tense = False
+ mood = False
+ voice = False
+ counter += 1
+ else:
+ break
+ if page_list[i].strip(": ").title() in tenses:
+ if not indent:
+ indent = count_indent(page_list[i])
+ tense = page_list[i].strip(": ").title()
+ voice = mood = gender = indent = unc_flag = False
+ voices = []
+ elif page_list[i].strip() == '(Uncontracted)':
+ unc_flag = True
+ elif tense:
+ if page_list[i].strip().title() in tenses[tense]:
+ voice = page_list[i].strip().title()
+ voices.append(page_list[i].strip().title())
+ index = 0
+ elif voice:
+ if page_list[i].strip().title() in moods:
+ mood = page_list[i].strip().title()
+ index = 0
+ elif mood:
+ if page_list[i].strip() == "Notes:":
+ voice = mood = gender = False
+ else:
+ if mood in mood_list:
+ if index not in range(len(list(persons.keys()))):
+ mood = False
+ else:
+ if mood == 'Imperative' and (index == 0 or index == 5):
+ index += 1
+ if tenses[tense][voice][mood][list(persons.keys())[index]] == '---':
+ if not unc_flag:
+ tenses[tense][voice][mood][list(persons.keys())[index]] = page_list[i].strip()
+ else:
+ build(uncontracted,tense,voice,mood)
+ uncontracted[tense][voice][mood][list(persons.keys())[index]] = page_list[i].strip()
+ index += 1
+ elif mood == 'Infinitive':
+ if index >= len(voices):
+ index %= len(voices)
+ if tenses[tense][voices[index]][mood] == '---':
+ if not unc_flag:
+ tenses[tense][voices[index]][mood] = page_list[i].strip()
+ else:
+ build(uncontracted,tense,voice,mood)
+ uncontracted[tense][voices[index]][mood] = page_list[i].strip()
+ index += 1
+ elif mood == 'Participle':
+ if index >= len(voices):
+ index %= len(voices)
+ if page_list[i].strip() in codec:
+ gender = codec[page_list[i].strip()]
+ continue
+ elif gender and tenses[tense][voices[index]][mood][gender] == '---':
+ if unc_flag == False:
+ tenses[tense][voices[index]][mood][gender] = page_list[i].strip()
+ else:
+ build(uncontracted,tense,voices[index],mood)
+ uncontracted[tense][voices[index]][mood][gender] = page_list[i].strip()
+ index += 1
+ for tense in uncontracted.keys():
+ tenses[f'{tense} (Uncontracted)'] = uncontracted[tense]
+ return tenses
+
+def retreive_noun_forms(template):
+ html_doc = tables.get_html(template['search word'])
+ print(f"template['gender'] = {template['gender']}")
+ three_ending = True if template['gender'] == '(m,f,n)' else False
+ two_ending = True if template['gender'] == '(m/f,n)' else False
+ print(f" three_ending = {three_ending}, two_ending = {two_ending}")
+ if 'proper' in template:
+ proper = True if template['proper'] else False
+ else:
+ proper = False
+ if html_doc == None:
+ return
+ soup = BeautifulSoup(html_doc, 'html.parser')
+ page_list = soup.prettify().split('\n')
+ page_list = clean_page_list(page_list)
+
+ cases = {"Nominative":'','Genitive':'','Dative':'','Accusative':'','Vocative':''}
+ numbers = {'Singular':'---','Dual':'---',"Plural":'---'}
+ genders = {'Masculine':'---','Feminine':'---','Neuter':'---'}
+ article = {'article':'','form':'---'}
+ if three_ending or two_ending:
+ for n in numbers:
+ numbers[n] = deepcopy(genders)
+ else:
+ for n in numbers:
+ numbers[n] = deepcopy(article)
+ for case in cases:
+ cases[case] = deepcopy(numbers)
+
+ case = False
+ indent = 0
+ for i in range(len(page_list)):
+ if count_indent(page_list[i]) < indent - 2:
+ break
+ if page_list[i].strip() in cases:
+ if not indent:
+ indent = count_indent(page_list[i])
+ case = page_list[i].strip()
+ index = 0
+ if case:
+ emdash = True if page_list[i].strip() == '—' else False
+ if three_ending:
+ if index % 2 != 0 or emdash:
+ if index <= 6:
+ number = 'Singular'
+ elif index <= 12:
+ number = 'Dual'
+ elif index <= 18:
+ number = 'Plural'
+ else:
+ if case == "Vocative":
+ break
+ case = False
+ continue
+ key_list = ['Masculine','Feminine','Neuter']
+ cases[case][number][key_list[index//2%3]] = page_list[i].strip()
+ if two_ending:
+ if index % 2 != 0 or emdash:
+ if index <= 4:
+ number = 'Singular'
+ elif index <= 8:
+ number = 'Dual'
+ elif index <= 12:
+ number = 'Plural'
+ else:
+ if case == "Vocative":
+ break
+ case = False
+ continue
+ key_list = ['Masculine','Neuter']
+ cases[case][number][key_list[index//2%2]] = page_list[i].strip()
+ elif not two_ending and not three_ending:
+ if index % 3 != 0 or emdash:
+ if index <= 3:
+ number = 'Singular'
+ elif index <= 6:
+ number = 'Dual'
+ elif index <= 9:
+ number = 'Plural'
+ else:
+ if case == "Vocative":
+ break
+ case = False
+ continue
+ if case == "Vocative":
+ if "notes" in page_list[i].lower():
+ break
+ elif proper and number != 'Singular':
+ break
+ cases[case][number]['form'] = page_list[i].strip()
+ index += 1
+ elif proper:
+ cases[case][number]['form'] = page_list[i].strip()
+ index += 1
+ else:
+ key_list = ['article','form']
+ cases[case][number][key_list[index%3-1]] = page_list[i].strip()
+ index += 2 if emdash else 1
+ return cases
+
+def add_tables():
+ tables_list = tables.get_tables('Ancient Greek')
+
+ table_info = {'title':'','type':''}
+ table_file = "AncientGreek-tables.txt"
+
+ while True:
+ print("Use table template? ('1' for yes, '0' to go back, any other key for no) 'AUTO' to auto-add all forms")
+ user_input = input(": ")
+ if user_input == '1':
+ template = tables.get_template('Ancient Greek')
+ if template == None:
+ continue
+ table_info['title'] = template['title']
+ elif user_input.upper() == 'AUTO':
+ auto_add([],table_info,table_file)
+ return
+ elif user_input == '0':
+ return
+ else:
+ template = None
+ print(f"Enter table title ('0' to go back)")
+ table_info['title'] = input(': ')
+ if table_info['title'] == '0':
+ continue
+
+ exit_second_loop = False
+ while not exit_second_loop:
+ complete = False
+ print("Select table type")
+ options = {'1':"'1'> noun\n",'2':"'2'> verb principal parts\n",'3':"'3'> verb conjugation\n",'4':"'4'> noun + dual\n",'5':"'5'> complete verb system\n",'6':"'6'> complete forms\n"}
+ options.update({'0':"'0'> to go back"})
+ user_input = get_selection(options)
+ if user_input == '0':
+ exit_second_loop = True
+ continue
+ elif user_input == '1':
+ table_info['type'] = 'noun'
+ elif user_input == '2':
+ table_info['type'] = 'parts'
+ elif user_input == '3':
+ table_info['type'] = 'conj'
+ elif user_input == '4':
+ table_info['type'] = 'dual'
+ elif user_input == '5':
+ table_info['type'] = 'conj'
+ complete = True
+ elif user_input == '6':
+ table_info['type'] = 'form'
+ complete = True
+
+ exit_third_loop = False
+ while not exit_third_loop:
+ if template:
+ table_info['definition'] = template['definition']
+ else:
+ definition = input("Enter definition ('0' to go back): ")
+ if definition == '0':
+ exit_third_loop = True
+ continue
+ table_info['definition'] = definition
+ while True:
+ print("Enter definition number (1-n) ('0' to go back)")
+ try:
+ user_input = int(input(": "))
+ except:
+ print("Invalid entry")
+ continue
+ if user_input == 0:
+ break
+ else:
+ table_info['defno'] = user_input
+
+ if complete:
+ if table_info['type'] == 'conj':
+ add_complete_verb_system(template,table_info,tables_list,table_file)
+ elif table_info['type'] == 'form':
+ add_complete_forms(template)
+ exit_second_loop = exit_third_loop = True
+ print("tables added succesfully")
+ continue
+
+ exit_loop_four = False
+ while not exit_loop_four:
+ print(f"Do you want to auto-retreive {table_info['title']}? ('1' for yes, '0' to go back, '00' to exit)")
+ user_input = input(": ")
+ if user_input == '1':
+ if table_info['type'] in ['parts','conj']:
+ table_info = auto_retreive_verb(table_info,template)
+ else:
+ table_info = auto_retreive_noun(table_info,template)
+ if result:
+ tables_list = tables.add_table(tables_list)
+ tables.save_tables(tables_list,'AncientGreektables.txt')
+ exit_loop_four = exit_third_loop = exit_second_loop = True
+ continue
+ elif user_input == '0':
+ exit_loop_four = exit_third_loop = exit_second_loop = True
+ continue
+ elif user_input == '00':
+ return
+
+def auto_add(tables_list,table_info,table_file):
+ change_path('templates')
+ myFiles = glob.glob('*.txt')
+ template_file = "AncientGreek_templates.txt"
+ if template_file not in myFiles:
+ print(f"file: {template_file} not found")
+ return
+ else:
+ with open(template_file,'r') as f:
+ templates = json.load(f)
+
+ for template in templates:
+ debug_print(f"Begin: {template['title']}")
+ i = template
+ #add_complete_forms(template)
+
+ table_info['definition'] = template['definition']
+ if template["POS"] == 'verb':
+
+ table_info['type'] = 'conj'
+ #for template in templates:
+
+ debug_print(f"Running add_complete_verb_system")
+ add_complete_verb_system(template,table_info,tables_list,table_file)
+ debug_print(f"add_complete_verb_system successful")
+
+ if template["POS"] == 'noun':
+
+ table_info['type'] = 'noun'
+ if template['gender'] == "(m,f,n)" or template['gender'] == "(m/f,n)":
+ continue
+
+ debug_print(f"Running auto_retreive_noun")
+ table_info = auto_retreive_noun(table_info,template)
+ debug_print(f"auto_retreive_noun successful")
+
+ debug_print(f"Running add_table")
+ tables_list = tables.add_table(tables_list,table_info)
+ debug_print(f"add_table successful")
+ tables.save_tables(tables_list,table_file)
+
+
+def empty(item):
+ if type(item) != dict:
+ return True if item == '---' or item == '—' else False
+ for key in item:
+ if not empty(item[key]):
+ return False
+ return True
+
+"""
+[{'title':'capere','instances':[
+{'root':template['title'],
+'features':{x:y for x,y in template['forms'] if x != 'form'}
+'principal:template['principal'],
+'definition':template['definition'],
+}
+]}
+]
+"""
+
+def add_complete_forms(template):
+ forms_list = tables.get_forms("Ancient Greek")
+ for i in range(len(template['forms'])):
+ if not debug_print:
+ print('*',end='',flush=True)
+ found = False
+ for x in range(len(forms_list)):
+ if forms_list[x]['title'] == template['forms'][i]['form']:
+ found = True
+ instance = {'form':template['forms'][i]['form']}
+ instance['root'] = template['title']
+ instance['features'] = {x:y for x,y in template['forms'][i].items() if x != 'form'}
+
+ same = True
+ for y in forms_list[x]['instances']:
+ for key in y['features'].keys():
+ if key not in instance['features']:
+ same = False
+ break
+ else:
+ if y['features'][key] != instance['features'][key]:
+ if debug_print:
+ print(f"NOT SAME {y['features']} AND {instance['features']}")
+ same = False
+ break
+ if not same:
+ break
+ if same:
+ debug_print(f"rejected DUPLICATE")
+ break
+ if 'tense' in instance['features']:
+ if instance['features']['tense'] not in ["Present",'Imperfect','Future','Aorist']:
+ debug_print(f"rejected {instance['features']['tense']}")
+ break
+ if 'mood' in instance['features']:
+ if instance['features']['mood'] in ["Subjunctive",'Imperative','Optative']:
+ debug_print(f"rejected {instance['features']['mood']}")
+ break
+ if 'number' in instance['features']:
+ if instance['features']['number'] == 'Dual':
+ debug_print(f"rejected {instance['features']['number']}")
+ break
+ if 'person' in instance['features']:
+ if instance['features']['person'] in ['2nd Person Dual','3rd Person Dual']:
+ debug_print(f"rejected {instance['features']['person']}")
+ break
+ instance['principal'] = template['principal']
+ instance['definition'] = template['definition']
+
+
+ debug_print("ADDING TO EXISTING")
+ debug_print(instance)
+ if not DEBUG:
+ print('<',end='',flush=True)
+ forms_list[x]['instances'].append(deepcopy(instance))
+
+
+ if not found:
+ form = {'title':template['forms'][i]['form']}
+ instance = {'form':template['forms'][i]['form']}
+ instance['root'] = template['title']
+ instance['features'] = {x:y for x,y in template['forms'][i].items() if x != 'form'}
+ if 'tense' in instance['features']:
+ if instance['features']['tense'] not in ["Present",'Imperfect','Future','Aorist']:
+ debug_print(f"rejected {instance['features']['tense']}")
+ continue
+ if 'mood' in instance['features']:
+ if instance['features']['mood'] in ["Subjunctive",'Imperative','Optative']:
+ debug_print(f"rejected {instance['features']['mood']}")
+ continue
+ if 'number' in instance['features']:
+ if instance['features']['number'] == 'Dual':
+ debug_print(f"rejected {instance['features']['number']}")
+ continue
+ if 'person' in instance['features']:
+ if instance['features']['person'] in ['2nd Person Dual','3rd Person Dual']:
+ debug_print(f"rejected {instance['features']['person']}")
+ continue
+ instance['principal'] = template['principal']
+ instance['definition'] = template['definition']
+ form['instances'] = [deepcopy(instance)]
+
+
+ debug_print("ADDING NEW")
+ debug_print(instance)
+ if not debug_print:
+ print('+',end='',flush=True)
+ forms_list.append(deepcopy(form))
+
+ file = 'AncientGreek_forms.txt'
+
+ tables.add_tables(forms_list)
+
+
+
+def add_complete_verb_system(template,table_info,tables_list,table_file):
+
+ table_info['principal'] = template['principal']
+ tenses = template['parts']
+ for tense in ["Present",'Imperfect','Future','Aorist']:
+ debug_print(f"Tense: {tense}")
+ for voice in ["Active","Middle/Passive","Middle",'Passive']:
+ debug_print(f"Voice: {voice}")
+
+ debug_print("Running assign_table_info")
+ table_info = assign_table_info(table_info,template,tenses,tense,voice,'Indicative')
+ debug_print("assign_table_info run succesfully")
+
+ if empty(table_info['parts']):
+ debug_print(f"\t\t{table_info['title']} was blank")
+ continue
+ else:
+ tables_list = tables.add_table(tables_list,table_info)
+ debug_print(f"\t\t{table_info['title']} saved")
+ table_info['type'] = 'parts'
+ table_info = assign_principle_parts(table_info,tenses,template)
+ tables_list = tables.add_table(tables_list,table_info)
+
+def auto_retreive_verb(table_info,template):
+ tenses = template['parts']
+ if table_info['type'] == 'parts':
+ table_info = assign_principle_parts(table_info,tenses,template)
+ return table_info
+ elif table_info['type'] == 'conj':
+ options1 = {'1':"Present",'2':'Imperfect','3':'Future','4':'Aorist','5':'Perfect'}
+ user_input = get_selection(options1,2)
+ tense = options1[user_input]
+ options2 = {'1':"Active",'2':"Middle/Passive",'3':"Middle",'4':'Passive'}
+ user_input = get_selection(options2,2)
+ voice = options2[user_input]
+ options3 = {'1':'Indicative','2':'Subjunctive','3':'Optative','4':'Imperative'}
+ user_input = get_selection(options3,2)
+ mood = options3[user_input]
+ table_info = assign_table_info(table_info,template,tenses,tense,voice,mood)
+ return table_info
+
+def assign_table_info(table_info,template,tenses,tense,voice,mood):
+ table_info['parts'] = {
+ '1st Person':{
+ 'Singular':tenses[tense][voice][mood]['1st Person Singular'],\
+ 'Plural':tenses[tense][voice][mood]['1st Person Plural']},\
+ '2nd Person':{
+ 'Singular':tenses[tense][voice][mood]['2nd Person Singular'],\
+ 'Plural':tenses[tense][voice][mood]['2nd Person Plural']},\
+ '3rd Person':{
+ 'Singular':tenses[tense][voice][mood]['3rd Person Singular'],\
+ 'Plural':tenses[tense][voice][mood]['3rd Person Plural']}}
+ table_info['parts'].update({'Infinitive':tenses[tense][voice]['Infinitive']})
+ table_info['parts'].update({'Participle':{
+ 'Masculine':tenses[tense][voice]['Participle']['Masculine'],\
+ 'Feminine':tenses[tense][voice]['Participle']['Feminine'],\
+ 'Neuter':tenses[tense][voice]['Participle']['Neuter']}})
+ if template:
+ table_info['title'] = f"{tense.title()} {voice.title()} {mood.title()}: {template['title']}"
+ return table_info
+
+def auto_retreive_noun(table_info,template):
+ table_info['principal'] = template['principal']
+ parts = template['parts']
+ case_keys = ["Nominative",'Genitive','Dative','Accusative','Vocative']
+ number_keys = ['Singular','Dual',"Plural"]
+ table_info['parts'] = {}
+ for case in case_keys:
+ table_info['parts'][case] = {}
+ for number in number_keys:
+ if number == 'Dual' and table_info['type'] != 'dual':
+ continue
+ if 'article' in parts[case][number]:
+ if parts[case][number]['article'] != "":
+ table_info['parts'][case][number] = parts[case][number]['article'] + " " + parts[case][number]['form']
+ else:
+ table_info['parts'][case][number] = parts[case][number]['form']
+ elif 'Masculine' in parts[case][number]:
+ table_info['parts'][case][number] = ", ".join([parts[case][number]['Masculine'], parts[case][number]['Feminine'], parts[case][number]['Neuter']])
+ if template:
+ table_info['title'] = f"{template['title']}"
+ return table_info
+
+def clean_page_list(page_list,exception=False):
+ offset = 0
+ for i in range(1,len(page_list)):
+ i = i - offset
+ if ' ' in page_list[i]:
+ page_list[i] = page_list[i].replace(' ',' ')
+ if page_list[i].strip()[0] == "<":
+ del page_list[i]
+ offset += 1
+
+ offset = 0
+ perfmidsubj = ['ὦ','ᾖς','ᾖ','ἦτον','εἴην','εἴης','εἴη','εἴητον','εἶτον','εἰήτην','εἴτην','ὦμεν','ἦτε','ὦσῐ','ὦσῐ(ν)','εἴημεν','εἶμεν','εἴητε','εἶτε','εἴησᾰν','εἶεν']
+ #articles = ["ὁ, ἡ" , "οἱ, αἱ" , "τοῦ, τῆς" , "τῷ, τῇ" , "τοῖς, ταῖς" , "τὸν, τὴν" , "τοὺς, τᾱ̀ς"]
+ for i in range(1,len(page_list)):
+ i = i - offset
+ if page_list[i].strip(' ') == 'passive' and page_list[i - 1].strip(' ') == 'middle/':
+ page_list[i] = 'middle/passive'
+ del page_list[i - 1]
+ offset += 1
+ elif page_list[i].strip(' ') == ',':
+ page_list[i - 1] = page_list[i - 1].rstrip(' ') + ", " + page_list[i + 1].strip(' ')
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i].strip(' ') == 'ν':
+ if page_list[i - 1].strip(' ') == '(':
+ page_list[i - 2] = page_list[i - 2].rstrip(' ') + '(ν)'
+ del page_list[i + 1]
+ del page_list[i]
+ del page_list[i - 1]
+ offset += 3
+ else:
+ page_list[i - 1] = page_list[i - 1].rstrip(' ') + '(ν)'
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i].strip(' ') == 'σ':
+ if page_list[i - 1].strip(' ') == '(':
+ page_list[i - 2] = page_list[i - 2].rstrip(' ') + '(σ)' + page_list[i + 2].strip(' ')
+ del page_list[i + 2]
+ del page_list[i + 1]
+ del page_list[i]
+ del page_list[i - 1]
+ offset += 4
+ else:
+ page_list[i - 1] = page_list[i - 1].rstrip(' ') + '(σ)' + page_list[i + 2].strip(' ')
+ del page_list[i + 2]
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 3
+ elif page_list[i].strip(' ') == '/':
+ page_list[i - 1] = page_list[i - 1].rstrip(' ') + "/" + page_list[i + 1].strip(' ')
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i].strip(' ')[:1] == ')' and page_list[i - 2].strip(' ')[-1] == '(':
+ page_list[i - 2] = page_list[i - 2].rstrip(" ") + page_list[i - 1].strip(" ") + page_list[i].strip(' ')
+ for x in range(2):
+ del page_list[i - 1]
+ offset += 2
+ elif page_list[i].strip(' ') in perfmidsubj and previous not in perfmidsubj and not exception:
+ page_list[i - 1] = page_list[i - 1].rstrip(' ') + ' ' + page_list[i].strip(' ')
+ previous = page_list[i].strip(' ')
+ del page_list[i]
+ offset += 1
+ elif page_list[i].strip()[0] == "<" or (len(page_list[i].strip()) == 1 and page_list[i].strip().isnumeric()):
+ del page_list[i]
+ offset += 1
+ else:
+ previous = ''
+ return page_list
+
+"""
+[{'title':'capere','instances':[
+{'root':template['title'],
+'features':{x:y for x,y in template['forms'] if x != 'form'}
+'principal:template['principal'],
+'definition':template['definition'],
+}
+]}
+]
+"""
+
+def features_join(features):
+ join = ""
+ if 'gender' in features:
+ join += " " + features['gender'] + ""
+ for x,y in features.items():
+ if x != 'article':
+ if x == "mood" and (y != "Infinitive" and y != 'Participle'):
+ join += " " + y + ""
+ elif x == 'gender':
+ pass
+ else:
+ join += " " + y + ""
+ return join.strip()
+
+def print_forms():
+ out_file = 'AncientGreek-FormCards.txt'
+ original_stdout = sys.stdout
+ change_path('flashcards')
+ sys.stdout = open(out_file,'w')
+ forms_list = tables.get_forms("Ancient Greek")
+ random_list = list(range(len(forms_list)))
+ random.shuffle(random_list)
+ for i in random_list:
+ print('· ' + forms_list[i]['title'] + '
|',end='')
+ for instance in forms_list[i]['instances']:
+ features = features_join(instance['features'])
+ if 'article' in instance['features']:
+ print('' + instance['features']['article'] + " " + instance['form'] + '
',end='')
+ else:
+ print('
',end='')
+ print(features,end='')
+ print(' form of: ' + instance['principal'] + '
',end='')
+ print("Definition: " + instance['definition'] + '
',end='')
+ print('|"forms"')
+ sys.stdout = original_stdout
+
+
+def print_tables(tables_list):
+ print_forms()
+ out_file = 'AncientGreek-TableCards.txt'
+ original_stdout = sys.stdout
+ change_path('flashcards')
+ sys.stdout = open(out_file,'w')
+ random_list = list(range(len(tables_list)))
+ random.shuffle(random_list)
+ for i in random_list:
+
+ if tables_list[i]['type'] != 'noun':
+ print('' + tables_list[i]['title'] + '
|',end='')
+ else:
+ print('Forms: ' + tables_list[i]['title'] + '
|',end='')
+
+ if tables_list[i]['definition']:
+ body_string = '' + tables_list[i]['definition'] + '
'
+ else:
+ body_string = ''
+ if tables_list[i]['principal'] and tables_list[i]['type'] != 'parts':
+ body_string += "Parts: " + tables_list[i]['principal'] + '
'
+ body_string += '
'
+
+ body_string = html_x.set_styles(body_string)
+
+ if tables_list[i]['type'] == 'parts':
+ body_string = html_x.create_table(body_string,tables_list[i]['parts'],'parts',1)
+ elif tables_list[i]['type'] == 'noun':
+ body_string = html_x.create_table(body_string,tables_list[i]['parts'],'noun',2)
+ elif tables_list[i]['type'] == 'conj':
+ parts = {k:v for k,v in tables_list[i]['parts'].items() if k != "Infinitive" and k != "Participle"}
+ body_string = html_x.create_table(body_string,parts,'conj',2)
+ body_string = html_x.create_style(body_string,1)
+ body_string = html_x.create_box(body_string,'Infinitive',tables_list[i]["parts"]["Infinitive"])
+ parts = {k:v for k,v in tables_list[i]['parts'].items() if k == "Participle"}
+ parts = {k:{'Participle':v} for k,v in parts['Participle'].items()}
+ body_string = html_x.create_table(body_string,parts,'Participle',1)
+
+ print(body_string + '|"table"')
+
+ sys.stdout = original_stdout
\ No newline at end of file
diff --git a/tables_latin_ext.py b/tables_latin_ext.py
new file mode 100644
index 0000000..c0f5c0b
--- /dev/null
+++ b/tables_latin_ext.py
@@ -0,0 +1,1113 @@
+
+from bs4 import BeautifulSoup
+
+import tables
+from load_dict import change_path
+from get_selection import get_selection
+from copy import deepcopy
+from unidecode import unidecode
+import html_x
+import random
+import sys
+import json
+import glob
+
+
+def new_template(heading="",handle="",definition="",POS=""):
+ template = {}
+ while True:
+ x = 'POS'
+ if POS != "verb" and POS != "noun" and POS != "adjective":
+ print("Enter choose template {x} ('0' to go back)")
+ print("'1'> noun/adj.")
+ print("'2'> verb")
+ print("type description for other (e.g. 'particle', 'not comparable', 'indeclinable')")
+ user_input = input(": ")
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ elif user_input == '1':
+ template[x] = 'noun/adj.'
+ elif user_input == '2':
+ template[x] = 'verb'
+ else:
+ template[x] = user_input
+ elif POS == "noun" or POS == "adjective":
+ template[x] = 'noun/adj.'
+ elif POS == "verb":
+ template[x] = 'verb'
+
+ if template[x] == 'noun/adj.':
+ x = 'gender'
+ options = {'0':f"Enter choose template {x} ('0' to go back)\n",
+ '1':"'1'> (m)\n",
+ '2':"'2'> (f)\n",
+ '3':"'3'> (m or f)\n",
+ '4':"'4'> (n)\n",
+ '5':"'5'> (m,f,n)\n",
+ '6':"'6'> (m/f,n)\n",
+ '7':"'7'> (m/f/n)\n",
+ '00':"'00' to quit\n"}
+ user_input = get_selection(options)
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ else:
+ template[x] = options[user_input][options[user_input].find("("):].strip("\n")
+ print("Proper noun? ('Y' for yes, any other key for no)")
+ user_input = input(": ")
+ template['proper'] = True if user_input.upper() == 'Y' else False
+ while True:
+ x = 'title'
+ if heading == "":
+ print(f"Enter template {x} ('0' to go back)")
+ user_input = input(": ")
+ if user_input == '0':
+ break
+ elif user_input == '00':
+ return
+ else:
+ template[x] = user_input
+ else:
+ template[x] = heading
+ x = 'search word'
+ if template['POS'] != 'noun/adj.' and template['POS'] != 'verb':
+ template['search word'] = None
+ elif handle == "":
+ template[x] = unidecode(user_input)
+ else:
+ template[x] = handle
+ while True:
+ if template['POS'] != 'noun/adj.' and template['POS'] != 'verb':
+ template['defno'] = None
+ else:
+ print("Enter definition number ('0' if unspecified)")
+ try:
+ template['defno'] = int(input(": "))
+ except:
+ print("Invalid entry")
+ continue
+
+ template = get_forms(template)
+ print(template['principal'])
+ print_parts(template['parts'])
+ x = 'definition'
+ if definition == "":
+ print(f"Enter template {x} ('0' to go back '00' to quit)")
+ user_input = input(": ")
+ if user_input == '0':
+ continue
+ elif user_input == '00':
+ return
+ else:
+ template[x] = user_input
+ else:
+ template[x] = definition
+ return template
+
+def edit_template(template):
+ while True:
+ options = {'1':f"Template \"{template['title']}\" options:\n'1' change definition\n",
+ '2':"'2' to display forms\n",
+ '3':"'3' to re-do forms\n",
+ '4':"'4' to delete\n",
+ '0':"'0' to go back\n"}
+ user_input = get_selection(options)
+
+ if user_input == '1':
+ print(f"Current definition: {template['definition']}")
+ user_input = input("Enter new definition ('0' to cancel): ")
+ if user_input == '0':
+ continue
+ else:
+ template['definition'] == user_input
+ elif user_input == '2':
+ print(template['principal'])
+ print_parts(template['parts'])
+ input("\n\nPress Enter to continue\n")
+ elif user_input == '3':
+ template = get_forms(template)
+ elif user_input == '4':
+ del template
+ return
+ elif user_input == '0':
+ return
+
+
+
+def print_parts(chunk,string='',outer_key=''):
+ if string != '' or outer_key != '':
+ string += " " + outer_key
+ if type(chunk) == dict:
+ for inner_key in chunk:
+ print_parts(chunk[inner_key],string,inner_key)
+ else:
+ if chunk != '---' and chunk != "–":
+ final_str = f"{string.lstrip():_<70}" + chunk
+ print(final_str)
+
+def get_forms(template):
+ if template['POS'] != 'noun/adj.' and template['POS'] != 'verb':
+ template['forms'] = [{'form':template['title']}]
+ template['principal'] = template['title'] + " (" + template['POS'] + ")"
+ template['parts'] = {'single form':template['title']}
+ return template
+ if template['POS'] == 'noun/adj.':
+ template['parts'] = retreive_noun_forms(template)
+ if template['gender'] == '(m,f,n)':
+ template['parts'] = fix_two_ending(template['parts'])
+ parts = template['parts']['Nominative']['Singular']
+ template['principal'] = ", ".join([x for x in parts.values()])
+ template['forms'] = inside_out_multi_noun(template['parts'])
+ elif template['gender'] == '(m/f,n)':
+ #print(template['parts']['Nominative']['Singular'])
+ template['parts'] = fix_two_ending(template['parts'])
+ parts = template['parts']['Nominative']['Singular']
+ template['principal'] = ", ".join([y for x,y in parts.items() if x != 'Feminine'])
+ template['forms'] = inside_out_multi_noun(template['parts'])
+ elif template['gender'] == '(m/f/n)':
+ template['parts'] = fix_two_ending(template['parts'])
+ part = template['parts']['Nominative']['Singular']["Masculine"]
+ nom = part
+ part = template['parts']['Genitive']['Singular']["Masculine"]
+ gen = part
+ template['principal'] = nom + ", " + gen
+ template['forms'] = inside_out_noun(template['parts'])
+ else:
+ part = template['parts']['Nominative']['Singular']
+ nom = part
+ part = template['parts']['Genitive']['Singular']
+ gen = part
+ template['principal'] = nom + ", " + gen + template['gender']
+ template['forms'] = inside_out_noun(template['parts'])
+ elif template['POS'] == 'verb':
+ template['parts'] = retreive_verb_forms(template)
+ result = assign_principle_parts({},template['parts'])
+ result = [y['Principal Part'] for y in result['parts'].values()]
+ template['principal'] = ", ".join(result)
+ print("GETTING FORMS")
+ template['forms'] = inside_out_verb(template['parts'])
+ return template
+
+def redo(templates):
+ for template in templates:
+ template = get_forms(template)
+ return templates
+
+def fix_two_ending(parts):
+ for case in parts:
+ for number in parts[case]:
+ if parts[case][number]["Feminine"] == "---":
+ parts[case][number]["Feminine"] = deepcopy(parts[case][number]["Masculine"])
+ if parts[case][number]["Neuter"] == "---":
+ parts[case][number]["Neuter"] = deepcopy(parts[case][number]["Masculine"])
+ return parts
+
+
+def remove_emdash(forms):
+ for form in forms:
+ if form['form'] == '—':
+ del form
+
+
+def inside_out_multi_noun(parts):
+ forms = []
+ print(parts)
+ for case in parts:
+ for number in parts[case]:
+ for gender in parts[case][number]:
+ if parts[case][number][gender] != "—":
+ if "," in parts[case][number][gender]:
+ for x in parts[case][number][gender].split(","):
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ elif "/" in parts[case][number][gender]:
+ for x in parts[case][number][gender].split("/"):
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ else:
+ print(f"{case} {number} {gender} = {parts[case][number][gender]}")
+ form = {'form':parts[case][number][gender]}
+ form['case'] = case
+ form['number'] = number
+ form['gender'] = gender
+ forms.append(deepcopy(form))
+ remove_emdash(forms)
+ return forms
+
+def inside_out_noun(parts):
+ forms = []
+ for case in parts:
+ for number in parts[case]:
+ if parts[case][number] != "—":
+ if "," in parts[case][number]:
+ for x in parts[case][number].split(","):
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ forms.append(deepcopy(form))
+ elif "/" in parts[case][number]:
+ for x in parts[case][number].split("/"):
+ form = {'form':x.strip()}
+ form['case'] = case
+ form['number'] = number
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[case][number]}
+ form['case'] = case
+ form['number'] = number
+ forms.append(deepcopy(form))
+ remove_emdash(forms)
+ return forms
+
+def inside_out_verb(parts):
+ change_path("texts")
+ with open('sum_forms.txt','r') as f:
+ sum_forms = json.load(f)
+ if parts['Present']['Active']['Indicative']['FPS'] == "sum":
+ exception = True
+ else:
+ exception = False
+ forms = []
+ for tense in parts:
+ for voice in parts[tense]:
+ for mood in parts[tense][voice]:
+ if mood == 'Infinitive':
+ if parts[tense][voice][mood] != "---":
+ if "," in parts[tense][voice][mood]:
+ split = parts[tense][voice][mood].split(",")
+ for x in split:
+ if x.strip() in sum_forms and not exception:
+ x = split[0][:split[0].find(" ")+1] + x.strip()
+ print(x)
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ elif "/" in parts[tense][voice][mood]:
+ for x in parts[tense][voice][mood].split("/"):
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[tense][voice][mood]}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ elif mood == 'Participle':
+ if parts[tense][voice][mood] != "---":
+ if "," in parts[tense][voice][mood]:
+ split = parts[tense][voice][mood].split(",")
+ for x in split:
+ if x.strip() in sum_forms and not exception:
+ x = split[0][:split[0].find(" ")+1] + x.strip()
+ print(x)
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ elif "/" in parts[tense][voice][mood]:
+ for x in parts[tense][voice][mood].split("/"):
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[tense][voice][mood]}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ forms.append(deepcopy(form))
+ else:
+ for person in parts[tense][voice][mood]:
+ if parts[tense][voice][mood][person] != "---":
+ if "," in parts[tense][voice][mood][person]:
+ split = parts[tense][voice][mood][person].split(",")
+ for x in split:
+ if x.strip() in sum_forms and not exception:
+ x = split[0][:split[0].find(" ")+1] + x.strip()
+ print(x)
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ elif "/" in parts[tense][voice][mood][person]:
+ for x in parts[tense][voice][mood][person].split("/"):
+ form = {'form':x.strip()}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ else:
+ form = {'form':parts[tense][voice][mood][person]}
+ form['tense'] = tense
+ form['voice'] = voice
+ form['mood'] = mood
+ form['person'] = person
+ forms.append(deepcopy(form))
+ remove_emdash(forms)
+ return forms
+
+def auto_parts(parts):
+ print("Enter look up word")
+ user_input = input(": ")
+ result = retreive_verb_forms({'search word':user_input,'title':''})
+ result = assign_principle_parts(result,result)
+ result = [y['Principal Part'] for y in result['parts'].values()]
+ result = ", ".join(result)
+ print("Does this look right ('1' to except '0' to discard)?")
+ print(result)
+ user_input = input(": ")
+ if user_input == '1':
+ return result
+ else:
+ return parts
+
+def assign_principle_parts(table_info,tenses,template=None):
+ table_info['parts'] = {
+ 'Present':{'Principal Part':tenses['Present']['Active']['Indicative']['FPS']},\
+ 'Infinitive':{'Principal Part':tenses['Present']['Active']['Infinitive']},\
+ 'Perfect Act.':{'Principal Part':tenses['Perfect']['Active']['Indicative']['FPS']},\
+ 'Perfect Pas.':{'Principal Part':tenses['Perfect']['Passive']['Participle']}}
+ if template:
+ table_info['title'] = f"Principal Parts: {template['title']}"
+ return table_info
+
+def retreive_verb_forms(template):
+ if 'specified' in template:
+ specified = template['specified']
+ else:
+ specified = 0
+ if template['search word'] == 'sum':
+ exception = True
+ else:
+ exception = False
+
+ html_doc = tables.get_html(template['search word'])
+ if html_doc == None:
+ return
+ soup = BeautifulSoup(html_doc, 'html.parser')
+ page_list = soup.prettify().split('\n')
+ page_list = clean_page_list(page_list,exception)
+
+ tenses = {"Present":'','Imperfect':'','Future':'','Future Perfect':'','Perfect':'','Pluperfect':''}
+ voices = {"Active":'','Passive':''}
+ moods = {'Indicative':[],'Subjunctive':[],'Imperative':[],"Infinitive":[],"Participle":[]}
+ mood_list = ['Indicative','Subjunctive','Imperative']
+ persons = {'FPS':'---','SPS':'---','TPS':'---','FPP':'---','SPP':'---','TPP':'---'}
+
+ for tense in tenses:
+ tenses[tense] = deepcopy(voices)
+ for voice in tenses[tense]:
+ tenses[tense][voice] = deepcopy(moods)
+ for mood in tenses[tense][voice]:
+ if mood in mood_list:
+ tenses[tense][voice][mood] = deepcopy(persons)
+ elif mood == 'Participle' or mood == 'Infinitive':
+ tenses[tense][voice][mood] = '---'
+
+ tense = False
+ mood = False
+ voice = False
+ count = 0
+ specified = 0
+ for i in range(len(page_list)):
+ if count < specified:
+ if page_list[i].strip() == 'Conjugation of':
+ count += 1
+ elif page_list[i].strip() == "verbal nouns":
+ break
+ elif page_list[i].strip(": ").title() in mood_list:
+ mood = page_list[i].strip(": ").title()
+ voice = False
+ tense = False
+ elif page_list[i].strip(": ")[:-1].title() in ['Infinitive','Participle']:
+ mood = page_list[i].strip(": ")[:-1].title()
+ columns = ['Active','Passive']
+ rows = ['Present','Perfect','Future','Present','Perfect','Future']
+ index = 0
+ continue
+ elif mood in mood_list:
+ if page_list[i].strip().title() in voices:
+ voice = page_list[i].strip().title()
+ index = 0
+ elif voice:
+ if page_list[i].strip().title() in tenses:
+ tense = page_list[i].strip().title()
+ index = 0
+ elif tense:
+ if index not in range(6):
+ tense = False
+ else:
+ if tenses[tense][voice][mood][list(persons.keys())[index]] == '---':
+ tenses[tense][voice][mood][list(persons.keys())[index]] = page_list[i].strip()
+ index += 1
+ elif mood in ['Infinitive','Participle']:
+ if index == 6:
+ mood = False
+ else:
+ tenses[rows[index]][columns[index//3]][mood] = page_list[i].strip()
+ index += 1
+ return tenses
+
+def count_indent(a):
+ return len(a) - len(a.lstrip())
+
+def manual_sort(cases,case,holder,multi=True):
+ print(f"\nSorting needed for {case} case")
+ genders = {"M":"Masculine","F":"Feminine","N":"Neuter"}
+ numbers = {"S":"Singular","P":"Plural"}
+ while True:
+ for word in holder:
+ user_input = ""
+ if multi:
+ while True:
+ print(f"Select gender for {word} ({case}) ('M', 'F', 'N') ('X' to discard)")
+ user_input = input(": ")
+ if user_input.upper() == "X":
+ break
+ if len(user_input) == 2:
+ user_input = list(user_input)
+ if user_input[0].upper() not in genders and user_input[1].upper() not in numbers:
+ print("Invalid entry")
+ continue
+ else:
+ gender = genders[user_input[0].upper()]
+ number = numbers[user_input[1].upper()]
+ break
+ if user_input.upper() not in genders:
+ print("Invalid entry")
+ continue
+ else:
+ gender = genders[user_input.upper()]
+ break
+ if user_input == "X":
+ break
+ while True:
+ if len(user_input) == 2:
+ break
+ print(f"Select number for {word} ({case}) ('S', 'P')")
+ user_input = input(": ")
+ if user_input.upper() not in numbers:
+ print("Invalid entry")
+ continue
+ else:
+ number = numbers[user_input.upper()]
+ break
+ if multi:
+ if cases[case][number][gender] != "---":
+ cases[case][number][gender] += ", " + word
+ else:
+ cases[case][number][gender] = word
+ else:
+ if cases[case][number] != "---":
+ cases[case][number] += ", " + word
+ else:
+ cases[case][number] = word
+ print("Like this? ('1' to accept, '2' to manually edit, any other key to try again)")
+ print_parts(cases[case])
+ user_input = input(": ")
+ if user_input == '1':
+ break
+ elif user_input == '2':
+ return manual_edit(cases,case)
+ else:
+ reset(cases[case])
+ return cases
+
+def reset(case):
+ for key in case:
+ if type(case[key]) == dict:
+ reset(case[key])
+ else:
+ case[key] = "---"
+
+def manual_edit(parts,case):
+ while True:
+ print("Select term to edit ('0' to finish)")
+ index = 1
+ key_holder = {}
+ for number in parts[case]:
+ if type(parts[case][number]) == dict:
+ for gender in parts[case][number]:
+ print(f"{index}. {case} {number} {gender} {parts[case][number][gender]}")
+ key_holder[str(index)] = {'number':number,'gender':gender}
+ index += 1
+ else:
+ print(f"{index}. {case} {number} {parts[case][number]}")
+ key_holder[str(index)] = {'number':number}
+ index += 1
+ user_input = input(": ")
+ if user_input == '0':
+ return parts
+ elif user_input in key_holder:
+ keys = key_holder[user_input]
+ print(f"Enter correct form for {case} {' '.join([x for x in key_holder[user_input].values()])} ('0' to go back)")
+ user_input = input(": ")
+ if user_input == '0':
+ continue
+ if 'gender' in keys:
+ parts[case][keys['number']][keys['gender']] = user_input
+ else:
+ parts[case][keys['number']] = user_input
+
+
+def retreive_noun_forms(template):
+ html_doc = tables.get_html(template['search word'])
+ if html_doc == None:
+ return
+ soup = BeautifulSoup(html_doc, 'html.parser')
+ page_list = soup.prettify().split('\n')
+ page_list = clean_page_list(page_list)
+
+ multi = True if template['gender'] in ["(m,f,n)","(m/f,n)","(m/f/n)"] else False
+ one_ending = True if template['gender'] == "(m/f/n)" else False
+ two_ending = True if template['gender'] == "(m/f,n)" else False
+ three_endiing = True if template['gender'] == "(m,f,n)" else False
+
+
+ cases = {"Nominative":'','Genitive':'','Dative':'','Accusative':'','Ablative':'','Vocative':''}
+ genders = {'Masculine':'---','Feminine':'---','Neuter':'---'}
+ numbers = {'Singular':'---',"Plural":'---'}
+ if multi:
+ for n in numbers:
+ numbers[n] = deepcopy(genders)
+ for case in cases:
+ cases[case] = deepcopy(numbers)
+
+ case = False
+ start = 0
+ last = False
+ holder = []
+ indent = 0
+ count = 0
+ specified = template['defno'] - 1
+ stop = False
+ for i in range(len(page_list)):
+ if count_indent(page_list[i]) < indent - 2:
+ stop = True
+ if page_list[i].strip().title() == "Case" or page_list[i].strip().title() == "Number":
+ start = 1
+ if page_list[i].strip().title() == "Singular" and start == 1:
+ start = 2
+ if (page_list[i].strip().title() == "Plural" or page_list[i].strip().title() == "Case / Gender") and start == 2:
+ start = 3
+ if count < specified:
+ count += 1
+ start = 0
+ if page_list[i].strip().title() in cases and start == 3 or stop:
+ if not indent:
+ indent = count_indent(page_list[i])
+ if case or stop:
+ if multi:
+ if len(holder) > 6:
+ cases = manual_sort(cases,case,holder)
+ elif len(holder) == 6:
+ if three_endiing:
+ cases[case]['Singular']['Masculine'] = holder[0]
+ cases[case]['Singular']["Feminine"] = holder[1]
+ cases[case]['Singular']['Neuter'] = holder[2]
+ cases[case]['Plural']['Masculine'] = holder[3]
+ cases[case]['Plural']["Feminine"] = holder[4]
+ cases[case]['Plural']['Neuter'] = holder[5]
+ else:
+ cases = manual_sort(cases,case,holder)
+ elif len(holder) == 5:
+ cases = manual_sort(cases,case,holder)
+ elif len(holder) == 4:
+ if two_ending:
+ cases[case]['Singular']['Masculine'] = holder[0]
+ cases[case]['Singular']['Neuter'] = holder[1]
+ cases[case]['Plural']['Masculine'] = holder[2]
+ cases[case]['Plural']['Neuter'] = holder[3]
+ else:
+ cases = manual_sort(cases,case,holder)
+ elif len(holder) == 3:
+ cases = manual_sort(cases,case,holder)
+ elif len(holder) == 2:
+ cases[case]['Singular']['Masculine'] = holder[0]
+ cases[case]['Plural']['Masculine'] = holder[1]
+ else:
+ if len(holder) > 2:
+ cases = manual_sort(cases,case,holder,False)
+ else:
+ cases[case]['Singular'] = holder[0]
+ cases[case]['Plural'] = holder[1]
+ if stop:
+ indent = 0
+ stop = False
+ break
+ holder = []
+ case = page_list[i].strip()
+ elif case:
+ holder.append(page_list[i].strip())
+
+ return cases
+
+def add_sum_forms(page_list,i,alt=''):
+ change_path('texts')
+ with open('sum_parts.txt','r') as f:
+ sum_forms = json.load(f)
+ if 'Imperfect' in page_list[i - 1].title():
+ tense = 'Imperfect'
+ elif 'Future' in page_list[i - 1].title():
+ tense = 'Future'
+ elif 'Present' in page_list[i - 1].title():
+ tense = 'Present'
+ if 'Indicative' in page_list[i - 1].title():
+ mood = 'indicative'
+ elif 'Subjunctive' in page_list[i - 1].title():
+ mood = 'subjunctive'
+ voice = 'active'
+ keys = ['tpp','spp','fpp','tps','sps','fps']
+ for key in keys:
+ if alt:
+ page_list.insert(i + 1,alt + "/" + page_list[i - 2].strip() + " " + sum_forms[tense][voice][mood][key])
+ else:
+ page_list.insert(i + 1,page_list[i - 2] + " " + sum_forms[tense][voice][mood][key])
+ return page_list
+
+
+def add_tables():
+
+ tables_list = tables.get_tables('Latin')
+ table_info = {'title':'','type':''}
+ table_file = "Latin-tables.txt"
+
+ while True:
+ print("Use table template? ('1' for yes, '0' to go back, any other key for no) 'AUTO' to auto-add all forms")
+ user_input = input(": ")
+ if user_input == '1':
+ template = tables.get_template('Latin')
+ if template == None:
+ continue
+ table_info['title'] = template['title']
+ elif user_input.upper() == 'AUTO':
+ auto_add(tables_list,table_info,table_file)
+ return
+ elif user_input == '0':
+ return
+ else:
+ template = None
+ print(f"Enter table title ('0' to go back)")
+ table_info['title'] = input(': ')
+ if table_info['title'] == '0':
+ continue
+
+ exit_second_loop = False
+ while not exit_second_loop:
+ complete = False
+ print("Select table type")
+ options = {'1':"'1'> noun\n",'2':"'2'> verb principal parts\n",'3':"'3'> verb conjugation\n",'4':"'4'> complete verb system\n",'5':"'5'> complete forms\n"}
+
+ options.update({'4':"'4'> complete verb system\n"})
+ options.update({'0':"'0'> to go back"})
+ user_input = get_selection(options)
+ if user_input == '0':
+ exit_second_loop = True
+ continue
+ elif user_input == '1':
+ table_info['type'] = 'noun'
+ elif user_input == '2':
+ table_info['type'] = 'parts'
+ elif user_input == '3':
+ table_info['type'] = 'conj'
+ elif user_input == '4':
+ table_info['type'] = 'conj'
+ complete = True
+ elif user_input == '5':
+ table_info['type'] = 'form'
+ complete = True
+
+ exit_third_loop = False
+ while not exit_third_loop:
+ if template:
+ table_info['definition'] = template['definition']
+ else:
+ definition = input("Enter definition ('0' to go back): ")
+ if definition == '0':
+ exit_third_loop = True
+ continue
+ table_info['definition'] = definition
+ while True:
+ print("Enter definition number (1-n) ('0' to go back)")
+ try:
+ user_input = int(input(": "))
+ except:
+ print("Invalid entry")
+ continue
+ if user_input == 0:
+ break
+ else:
+ table_info['specified'] = user_input
+
+ if complete:
+ if table_info['type'] == 'conj':
+ add_complete_verb_system(template,table_info,tables_list,table_file)
+ elif table_info['type'] == 'form':
+ add_complete_forms(template)
+ exit_second_loop = exit_third_loop = True
+ prtin("tables added succesfully")
+ continue
+
+ exit_loop_four = False
+ while not exit_loop_four:
+ print(f"Do you want to auto-retreive {table_info['title']}? ('1' for yes, '0' to go back, '00' to exit)")
+ user_input = input(": ")
+ if user_input == '1':
+ if table_info['type'] in ['parts','conj']:
+ result = auto_retreive_verb(table_info,template)
+ else:
+ result = auto_retreive_noun(table_info,template)
+ if result:
+ tables_list = tables.add_table(tables_list,table_info)
+ tables.save_tables(tables_list,table_file)
+ exit_loop_four = exit_third_loop = exit_second_loop = True
+ continue
+ elif user_input == '0':
+ exit_loop_four = exit_third_loop = exit_second_loop = True
+ continue
+ elif user_input == '00':
+ return
+
+def auto_add(tables_list,table_info,table_file):
+ change_path('templates')
+ myFiles = glob.glob('*.txt')
+ template_file = "Latin_templates.txt"
+ if template_file not in myFiles:
+ return
+ else:
+ with open(template_file,'r') as f:
+ templates = json.load(f)
+ for template in templates:
+ print(template['title'])
+ i = template
+ add_complete_forms(template)
+ table_info['definition'] = template['definition']
+ if template["POS"] == 'verb':
+ table_info['type']= 'conj'
+ add_complete_verb_system(template,table_info,tables_list,table_file)
+ if template["POS"] == 'noun/adj.':
+ table_info['type']= 'noun'
+ if template['gender'] == "(m,f,n)" or template['gender'] == "(m/f,n)" or template['gender'] == '(m/f/n)':
+ continue
+ table_info = auto_retreive_noun(table_info,template)
+ tables_list = tables.add_table(tables_list,table_info)
+ tables.save_tables(tables_list,table_file)
+
+def empty(item):
+ if type(item) != dict:
+ return True if item == '---' or item == '—' else False
+ for key in item:
+ if not empty(item[key]):
+ return False
+ return True
+
+def add_complete_forms(template):
+ return
+ forms_list = tables.get_forms("Latin")
+ for i in range(len(template['forms'])):
+ found = False
+ for x in range(len(forms_list)):
+ if forms_list[x]['title'] == unidecode(template['forms'][i]['form']):
+ found = True
+ instance = {'form':template['forms'][i]['form']}
+ instance['root'] = template['title']
+ instance['features'] = {x:y for x,y in template['forms'][i].items() if x != 'form'}
+ for y in forms_list[x]['instances']:
+ same = True
+ for key in y['features'].keys():
+ if key not in instance['features']:
+ same = False
+ break
+ else:
+ if y['features'][key] != instance['features'][key]:
+ #print(f"NOT SAME {y['features']} AND {instance['features']}")
+ same = False
+ break
+ if same:
+ break
+ if same:
+ print(f"rejected DUPLICATE")
+ break
+ '''
+ if 'tense' in instance['features']:
+ if instance['features']['tense'] not in ["Present",'Imperfect','Future']:
+ #print(f"rejected {instance['features']['tense']}")
+ break
+ if 'mood' in instance['features']:
+ if instance['features']['mood'] in ["Subjunctive",'Imperative']:
+ #print(f"rejected {instance['features']['mood']}")
+ break
+ '''
+ instance['principal'] = template['principal']
+ instance['definition'] = template['definition']
+ print("ADDING TO EXISTING")
+ print(instance)
+ forms_list[x]['instances'].append(deepcopy(instance))
+ if not found:
+ form = {'title':unidecode(template['forms'][i]['form'])}
+ instance = {'form':template['forms'][i]['form']}
+ instance['root'] = template['title']
+ instance['features'] = {x:y for x,y in template['forms'][i].items() if x != 'form'}
+ '''
+ if 'tense' in instance['features']:
+ if instance['features']['tense'] not in ["Present",'Imperfect','Future']:
+ #print(f"rejected {instance['features']['tense']}")
+ continue
+ if 'mood' in instance['features']:
+ if instance['features']['mood'] in ["Subjunctive",'Imperative']:
+ #print(f"rejected {instance['features']['mood']}")
+ continue
+ '''
+ instance['principal'] = template['principal']
+ instance['definition'] = template['definition']
+ form['instances'] = [deepcopy(instance)]
+ print("ADDING NEW")
+ print(instance)
+ forms_list.append(deepcopy(form))
+ tables.save_tables(forms_list,'Latin_forms.txt')
+
+def add_complete_verb_system(template,table_info,tables_list,table_file):
+ table_info['principal'] = template['principal']
+ tenses = template['parts']
+ for tense in ["Present",'Imperfect','Future','Future Perfect','Perfect',"Pluperfect"]:
+ for voice in ["Active",'Passive']:
+ table_info = assign_table_info(table_info,template,tenses,tense,voice)
+ if empty(table_info['parts']):
+ #print(f"\t\t\t\t\t\t\t\t{table_info['title']} was blank")
+ continue
+ else:
+ tables_list = tables.add_table(tables_list,table_info)
+ tables.save_tables(tables_list,table_file)
+ #print(f"\t\t\t\t\t\t\t\t{table_info['title']} saved")
+ table_info['type'] = 'parts'
+ table_info = assign_principle_parts(table_info,tenses,template)
+ tables_list = tables.add_table(tables_list,table_info)
+ tables.save_tables(tables_list,table_file)
+
+def auto_retreive_verb(table_info,template):
+ tenses = template['parts']
+ if table_info['type'] == 'parts':
+ table_info = assign_principle_parts(table_info,tenses,template)
+ return table_info
+ elif table_info['type'] == 'conj':
+ options1 = {'1':"Present",'2':'Imperfect','3':'Future','4':'Perfect','5':'Pluperfect','6':'Future Perfect'}
+ user_input = get_selection(options1,2)
+ tense = options1[user_input]
+ options2 = {'1':"Active",'2':'Passive'}
+ user_input = get_selection(options2,2)
+ voice = options2[user_input]
+ options3 = {'1':'Indicative','2':'Subjunctive','3':'Imperative'}
+ user_input = get_selection(options3,2)
+ mood = options3[user_input]
+ table_info = assign_table_info(table_info,template,tenses,tense,voice,mood)
+ return table_info
+
+
+
+def assign_table_info(table_info,template,tenses,tense,voice):
+ x = 'Indicative'
+ table_info['parts'] = {'1st Person':{'Singular':tenses[tense][voice][x]['FPS'],'Plural':tenses[tense][voice][x]['FPP']},\
+ '2nd Person':{'Singular':tenses[tense][voice][x]['SPS'],'Plural':tenses[tense][voice][x]['SPP']},\
+ '3rd Person':{'Singular':tenses[tense][voice][x]['TPS'],'Plural':tenses[tense][voice][x]['TPP']}}
+ table_info['parts'].update({'Infinitive':tenses[tense][voice]['Infinitive']})
+ table_info['parts'].update({'Participle':tenses[tense][voice]['Participle']})
+ x = 'Imperative'
+ table_info['parts'].update({'Imperative':{'1st Person':{'Singular':tenses[tense][voice][x]['FPS'],'Plural':tenses[tense][voice][x]['FPP']},\
+ '2nd Person':{'Singular':tenses[tense][voice][x]['SPS'],'Plural':tenses[tense][voice][x]['SPP']},\
+ '3rd Person':{'Singular':tenses[tense][voice][x]['TPS'],'Plural':tenses[tense][voice][x]['TPP']}}})
+ x = 'Subjunctive'
+ table_info['parts'].update({'Subjunctive':{'1st Person':{'Singular':tenses[tense][voice][x]['FPS'],'Plural':tenses[tense][voice][x]['FPP']},\
+ '2nd Person':{'Singular':tenses[tense][voice][x]['SPS'],'Plural':tenses[tense][voice][x]['SPP']},\
+ '3rd Person':{'Singular':tenses[tense][voice][x]['TPS'],'Plural':tenses[tense][voice][x]['TPP']}}})
+ if template:
+ table_info['title'] = f"{tense.title()} {voice.title()}: {template['title']}"
+ return table_info
+
+def auto_retreive_noun(table_info,template):
+ table_info['principal'] = template['principal']
+ parts = template['parts']
+ case_keys = ["Nominative",'Genitive','Dative','Accusative','Ablative','Vocative']
+ number_keys = ['Singular',"Plural"]
+ table_info['parts'] = {}
+ for case in case_keys:
+ table_info['parts'][case] = {}
+ for number in number_keys:
+ if 'Masculine' not in parts[case][number]:
+ table_info['parts'][case][number] = parts[case][number]
+ elif 'Masculine' in parts[case][number]:
+ table_info['parts'][case][number] = ", ".join([parts[case][number]['Masculine'], parts[case][number]['Feminine'], parts[case][number]['Neuter']])
+ if template:
+ table_info['title'] = f"{template['title']}"
+ return table_info
+
+
+
+
+
+def clean_page_list(page_list,exception=False):
+ offset = 0
+ for i in range(1,len(page_list)):
+ i = i - offset
+ if ' ' in page_list[i]:
+ page_list[i] = page_list[i].replace(' ',' ')
+ if page_list[i].strip()[0] == "<":
+ del page_list[i]
+ offset += 1
+
+ offset = 0
+ sum_infinitive = ['īrī','esse']
+ for i in range(1,len(page_list)):
+ i = i - offset
+ if page_list[i].strip(' ') == ',':
+ page_list[i - 1] = page_list[i - 1].strip(' ') + ", " + page_list[i + 1].strip(' ')
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i].strip(' ') == 'sum' and page_list[i - 1].strip(' ')[0] == '+' and page_list[i - 1].strip(' ')[-2:] == 'of':
+ if page_list[i - 3].strip() == 'or':
+ page_list = add_sum_forms(page_list,i,page_list[i - 4].strip())
+ for x in range(5):
+ del page_list[i - 4]
+ offset += 5
+ else:
+ page_list = add_sum_forms(page_list,i)
+ for x in range(3):
+ del page_list[i - 2]
+ offset += 3
+ elif page_list[i].strip(' ') == '/':
+ page_list[i - 1] = page_list[i - 1].strip(' ') + "/" + page_list[i + 1].strip(' ')
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i].strip(' ') in sum_infinitive and previous not in sum_infinitive and not exception:
+ page_list[i - 1] = page_list[i - 1].strip(' ') + ' ' + page_list[i].strip(' ')
+ previous = page_list[i].strip(' ')
+ del page_list[i]
+ offset += 1
+ elif page_list[i].strip()[0] == "<" or (len(page_list[i].strip()) == 1 and page_list[i].strip().isnumeric()):
+ del page_list[i]
+ offset += 1
+ else:
+ previous = ''
+ return page_list
+
+def filter_cards(tables_list,random_list):
+ filters = {
+ 'Pluperfect Passive':97,
+ 'Future Perfect Passive':97,
+ 'Pluperfect':75,
+ 'Future Perfect':75,
+ 'Perfect Passive':75,
+ 'Imperfect Passive':90,
+ 'Imperfect Active':65,
+ 'Present Passive':50,
+ 'Future Passive':65,
+ 'Future Active':25,
+ }
+ for i in range(len(tables_list)):
+ r = random.randrange(0,100,1)
+ for x in filters:
+ if x in tables_list[i]['title']:
+ if r < filters[x]:
+ random_list.remove(i)
+ break
+ return random_list
+
+def features_join(features):
+ join = ""
+ if 'gender' in features:
+ join += " " + features['gender'] + ""
+ for x,y in features.items():
+ if x == "mood" and (y != "Infinitive" and y != 'Participle'):
+ join += " " + y + ""
+ elif x == 'gender':
+ pass
+ else:
+ join += " " + y + ""
+ return join.strip()
+
+def print_forms():
+ out_file = 'Latin-FormCards.txt'
+ original_stdout = sys.stdout
+ change_path('flashcards')
+ sys.stdout = open(out_file,'w')
+ forms_list = tables.get_forms("Latin")
+ random_list = list(range(len(forms_list)))
+ random.shuffle(random_list)
+ for i in random_list:
+ print('· ' + unidecode(forms_list[i]['title']) + '
|',end='')
+ for instance in forms_list[i]['instances']:
+ features = features_join(instance['features'])
+ if features:
+ print('' + instance['form'] + '
',end='')
+ else:
+ print('
',end='')
+ print(features,end='')
+ print(' form of: ' + instance['principal'] + '
',end='')
+ print("Definition: " + instance['definition'] + '
',end='')
+ print('|"forms"')
+ sys.stdout = original_stdout
+
+def print_tables(tables_list):
+ print_forms()
+ out_file = 'Latin-TableCards.txt'
+ original_stdout = sys.stdout
+ change_path('flashcards')
+ sys.stdout = open(out_file,'w')
+ #random_list = list(range(len(tables_list)))
+ #random_list = filter_cards(tables_list,random_list)
+ #random.shuffle(random_list)
+ for i in range(len(tables_list)):
+
+
+ if tables_list[i]['type'] != 'noun':
+ print('' + tables_list[i]['title'] + '
|',end='')
+ else:
+ print('Forms: ' + tables_list[i]['title'] + '
|',end='')
+
+ if tables_list[i]['definition']:
+ body_string = '' + tables_list[i]['definition'] + '
'
+ else:
+ body_string = ''
+
+ body_string = html_x.set_styles(body_string)
+
+ if tables_list[i]['type'] == 'parts':
+ body_string = html_x.create_table(body_string,tables_list[i]['parts'],'parts',1)
+ elif tables_list[i]['type'] == 'noun':
+ body_string = html_x.create_table(body_string,tables_list[i]['parts'],'noun',2)
+ elif tables_list[i]['type'] == 'conj':
+ parts = {k:v for k,v in tables_list[i]['parts'].items() if k != "Infinitive" and k != "Participle" and k != "Imperative" and k != "Subjunctive"}
+ body_string = html_x.create_table(body_string,parts,'conj',2)
+ body_string = html_x.create_box(body_string,'Infinitive',tables_list[i]["parts"]["Infinitive"])
+ body_string = html_x.create_box(body_string,'Participle',tables_list[i]["parts"]["Participle"])
+ if 'Subjunctive' in tables_list[i]['parts']:
+ body_string += 'Subjunctive:
'
+ body_string = html_x.create_table(body_string,tables_list[i]['parts']['Subjunctive'],'conj',2)
+ if 'Imperative' in tables_list[i]['parts']:
+ body_string += 'Imperative:
'
+ body_string = html_x.create_table(body_string,tables_list[i]['parts']['Imperative'],'conj',2)
+
+
+ print(body_string + '|"table"')
+
+ sys.stdout = original_stdout
\ No newline at end of file
diff --git a/tables_oe_ext.py b/tables_oe_ext.py
new file mode 100644
index 0000000..50e2ae4
--- /dev/null
+++ b/tables_oe_ext.py
@@ -0,0 +1,316 @@
+
+from bs4 import BeautifulSoup
+import tables
+import html_x
+from load_dict import change_path
+from get_selection import get_selection
+from copy import deepcopy
+import random
+import sys
+
+def add_tables():
+
+ tables_list = tables.get_tables('Old English')
+ table_info = {'title':'','type':''}
+ table_file = "OldEnglishtables.txt"
+
+ while True:
+ print("Use table template? ('1' for yes, '0' to go back, any other key for no)")
+ user_input = input(": ")
+ if user_input == '1':
+ template = tables.get_template('Old English')
+ if template == None:
+ continue
+ table_info['title'] = template['title']
+ elif user_input == '0':
+ return
+ else:
+ template = None
+ print(f"Enter table title ('0' to go back)")
+ table_info['title'] = input(': ')
+ if table_info['title'] == '0':
+ continue
+
+ exit_second_loop = False
+ while not exit_second_loop:
+ complete = False
+ print("Select table type")
+ options = {'1':"'1'> noun\n",'2':"'2'> verb conjugation\n"}
+ options.update({'0':"'0'> to go back"})
+ user_input = get_selection(options)
+ if user_input == '0':
+ exit_second_loop = True
+ continue
+ elif user_input == '1':
+ table_info['type'] = 'noun'
+ elif user_input == '2':
+ table_info['type'] = 'conj'
+
+ exit_third_loop = False
+ while not exit_third_loop:
+ if template:
+ table_info['definition'] = template['definition']
+ else:
+ definition = input("Enter definition ('0' to go back): ")
+ if definition == '0':
+ exit_third_loop = True
+ continue
+ table_info['definition'] = definition
+ while True:
+ print("Enter definition number (1-n) ('0' to go back)")
+ try:
+ user_input = int(input(": "))
+ except:
+ print("Invalid entry")
+ continue
+ if user_input == 0:
+ break
+ else:
+ table_info['specified'] = user_input
+
+ exit_loop_four = False
+ while not exit_loop_four:
+ print(f"Do you want to auto-retreive {table_info['title']}? ('1' for yes, '0' to go back, '00' to exit)")
+ user_input = input(": ")
+ if user_input == '1':
+ if table_info['type'] in ['parts','conj']:
+ result = auto_retreive_verb(table_info,template)
+ else:
+ result = auto_retreive_noun(table_info,template)
+ if result:
+ tables_list = tables.save_table(tables_list,table_info,'Old English')
+ tables.pop_template(template,'Old English')
+ exit_loop_four = exit_third_loop = exit_second_loop = True
+ continue
+ elif user_input == '0':
+ exit_loop_four = exit_third_loop = exit_second_loop = True
+ continue
+ elif user_input == '00':
+ return
+
+def empty(item):
+ if type(item) != dict:
+ return True if item == '---' or item == '—' else False
+ for key in item:
+ if not empty(item[key]):
+ return False
+ return True
+
+def auto_retreive_verb(table_info,template):
+ moods = retreive_verb_forms(template)
+ if moods == None:
+ return None
+ table_info['parts'] = moods
+ return True
+
+def auto_retreive_noun(table_info,template):
+ cases = retreive_noun_forms(template)
+ if cases == None:
+ return None
+ case_keys = ["Nominative",'Genitive','Dative','Accusative']
+ number_keys = ['Singular',"Plural"]
+ parts = {}
+ for case in case_keys:
+ parts[case] = {}
+ for number in number_keys:
+ parts[case][number] = cases[case.lower()][number]
+ table_info['parts'] = parts
+ if template:
+ table_info['title'] = f"{template['title']}"
+ return True
+
+def retreive_verb_forms(template):
+ if 'specified' in template:
+ specified = template['specified']
+ else:
+ specified = 0
+ html_doc = tables.get_html(template)
+ if html_doc == None:
+ return
+ soup = BeautifulSoup(html_doc, 'html.parser')
+ page_list = soup.prettify().split('\n')
+ page_list = clean_page_list(page_list)
+
+ tenses = {"present tense":'','past tense':''}
+ tenses_2 = {"present":'','past':''}
+ moods = {"infinitive":[],'indicative':[],'subjunctive':[],'imperative':[],"participle":[]}
+ mood_list = ["infinitive",'indicative mood','subjunctive','imperative',"participle"]
+ persons_1 = {'1p sing.':'---','2p sing.':'---','3p sing.':'---','plural':'---'}
+ person_list = {'first person singular':'1p sing.','second person singular':'2p sing.','third person singular':'3p sing.','plural':'plural'}
+ persons_2 = {'singular':'---','plural':'---'}
+
+ moods['infinitive'] = []
+ moods['indicative'] = deepcopy(persons_1)
+ for key in persons_1:
+ moods['indicative'][key] = deepcopy(tenses)
+ moods['subjunctive'] = deepcopy(persons_2)
+ for key in persons_2:
+ moods['subjunctive'][key] = deepcopy(tenses)
+ moods['imperative'] = deepcopy(persons_2)
+ moods['participle'] = deepcopy(tenses_2)
+
+ mood = False
+ for i in range(len(page_list)):
+ if page_list[i].strip(" ") in mood_list:
+ mood = page_list[i].strip(" ")
+ if mood == 'indicative mood':
+ mood = 'indicative'
+ person = tense = False
+ index = 0
+ elif mood == 'infinitive':
+ moods[mood].append(page_list[i].strip(" "))
+ elif mood == 'indicative':
+ if page_list[i].strip(" ") in person_list:
+ person = person_list[page_list[i].strip(" ")]
+ t_list = list(tenses.keys())
+ index = 0
+ elif index < 2 and person:
+ moods[mood][person][t_list[index]] = page_list[i].strip(" ")
+ index += 1
+ elif index > 1:
+ mood = person = False
+ elif mood == 'subjunctive':
+ if page_list[i].strip(" ") in persons_2:
+ person = page_list[i].strip(" ")
+ t_list = list(tenses.keys())
+ index = 0
+ elif index < 2 and person:
+ moods[mood][person][t_list[index]] = page_list[i].strip(" ")
+ index += 1
+ elif index > 1:
+ mood = person = False
+ elif mood == 'imperative':
+ if page_list[i].strip(" ") in persons_2:
+ person = page_list[i].strip(" ")
+ index = 0
+ elif index < 2 and person:
+ moods[mood][person] = page_list[i].strip(" ")
+ index += 1
+ elif index > 1:
+ mood = person = False
+ elif mood == 'participle':
+ t_list = list(tenses_2.keys())
+ if page_list[i].strip(" ") in tenses_2:
+ pass
+ elif index < 2:
+ moods[mood][t_list[index]] = page_list[i].strip(" ")
+ index += 1
+ elif index > 1:
+ mood = tense = False
+ return moods
+
+def retreive_noun_forms(template):
+ html_doc = tables.get_html(template)
+ if html_doc == None:
+ return
+ soup = BeautifulSoup(html_doc, 'html.parser')
+ page_list = soup.prettify().split('\n')
+ page_list = clean_page_list(page_list)
+
+ cases = {"nominative":'','genitive':'','dative':'','accusative':''}
+ numbers = {'Singular':'---',"Plural":'---'}
+ for case in cases:
+ cases[case] = deepcopy(numbers)
+
+ start = 0
+ case = False
+ for i in range(len(page_list)):
+ if page_list[i].strip() == "Case":
+ start = 1
+ if page_list[i].strip() == "Singular" and start == 1:
+ start = 2
+ if page_list[i].strip() == "Plural" and start == 2:
+ start = 3
+ if page_list[i].strip() in cases and start == 3:
+ case = page_list[i].strip()
+ index = 0
+ elif case:
+ if index == 0:
+ number = 'Singular'
+ elif index == 1:
+ number = 'Plural'
+ elif index > 1:
+ index = 0
+ case = False
+ continue
+ if cases[case][number] == "---":
+ cases[case][number] = page_list[i].strip()
+ index += 1
+ return cases
+
+def clean_page_list(page_list):
+ offset = 0
+ for i in range(1,len(page_list)):
+ i = i - offset
+ if ' ' in page_list[i]:
+ page_list[i] = page_list[i].replace(' ',' ')
+ if page_list[i].strip()[0] == "<":
+ del page_list[i]
+ offset += 1
+
+ offset = 0
+ for i in range(1,len(page_list)):
+ i = i - offset
+ if page_list[i].strip(' ') == ',':
+ page_list[i - 1] = page_list[i - 1].strip(' ') + ", " + page_list[i + 1].strip(' ')
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i].strip(' ') == '/':
+ page_list[i - 1] = page_list[i - 1].strip(' ') + "/" + page_list[i + 1].strip(' ')
+ del page_list[i + 1]
+ del page_list[i]
+ offset += 2
+ elif page_list[i - 1].strip(' ') == ')' and len(page_list[i - 2].strip(' ')) < 4 and page_list[i - 3].strip(' ') == '(':
+ page_list[i] = "(" + page_list[i - 2].strip(' ') + ")" + page_list[i].strip(' ')
+ for x in range(3):
+ del page_list[i - 3]
+ offset += 3
+ elif page_list[i].strip()[0] == "<" or (len(page_list[i].strip()) == 1 and page_list[i].strip().isnumeric()):
+ del page_list[i]
+ offset += 1
+ else:
+ previous = ''
+ return page_list
+
+def print_tables(tables_list):
+ out_file = 'OldEnglishflashcardtables.txt'
+ original_stdout = sys.stdout
+ change_path('flashcards')
+ sys.stdout = open(out_file,'w')
+ random_list = list(range(len(tables_list)))
+ random.shuffle(random_list)
+ for i in random_list:
+
+ print('Forms: ' + tables_list[i]['title'] + '
|',end='')
+
+ if tables_list[i]['definition']:
+ body_string = '' + tables_list[i]['definition'] + '
'
+ else:
+ body_string = ''
+
+ body_string = html_x.set_styles(body_string)
+
+ if tables_list[i]['type'] == 'noun':
+ body_string = html_x.create_table(body_string,tables_list[i]['parts'],'noun',2)
+ elif tables_list[i]['type'] == 'conj':
+ body_string += 'infinitive:
'
+ body_string = html_x.create_box(body_string,tables_list[i]["parts"]["infinitive"][0],tables_list[i]["parts"]["infinitive"][1])
+ body_string += 'indicative:
'
+ indicative = tables_list[i]['parts']['indicative']
+ body_string = html_x.create_table(body_string,indicative,'',2)
+ body_string += 'subjunctive:
'
+ subjunctive = tables_list[i]['parts']['subjunctive']
+ body_string = html_x.create_table(body_string,subjunctive,'',2)
+ body_string += 'imperative:
'
+ imperative = tables_list[i]['parts']['imperative']
+ body_string = html_x.create_style(body_string,1)
+ body_string = html_x.create_body(body_string,imperative,'')
+ body_string += 'participle:
'
+ participle = tables_list[i]['parts']['participle']
+ body_string = html_x.create_style(body_string,1)
+ body_string = html_x.create_body(body_string,participle,'')
+
+ print(body_string + '|"table"')
+
+ sys.stdout = original_stdout
\ No newline at end of file
diff --git a/word_methods.py b/word_methods.py
new file mode 100644
index 0000000..b153386
--- /dev/null
+++ b/word_methods.py
@@ -0,0 +1,429 @@
+
+'''
+Description:
+
+ copy word:
+ takes a fetch and new_word
+ returns a new_word
+ take a result from the wiktionary parser and
+ copies a simpler version into a new_word taken as an argument
+
+ getTags:
+ takes a list of tags and allows user to add or delete tags
+'''
+
+#from get_simple import get_simple
+from edit_dictionary import chop_parens
+import re
+from unidecode import unidecode
+import get_selection
+import copy
+
+
+# REMOVE OR
+# # # # # # # # # #
+def remove_or(text):
+ text = text.split()
+ offset = 0
+ for i in range(len(text)):
+ i = i - offset
+ if text[i] == 'or':
+ text[i-1] += ","
+ del text[i]
+ offset += 1
+ new_text = ''
+ for i in range(len(text)):
+ new_text += text[i] + " "
+ return new_text
+# END REMOVE OR
+
+# VERB EDIT
+# # # # # # # # #
+def verb_edit(text):
+ # slip definitions into individual words
+ text = text.split(" ")
+
+ offset = 0
+ # delete 'I's replace 'am's with 'be'
+ for num in range(len(text)):
+ num = num - offset
+ if text[num] == "I":
+ del text[num]
+ offset += 1
+ elif text[num].strip(";,") == "myself":
+ text[num] = text[num].replace("myself","oneself")
+ elif text[num] == "am":
+ text[num] = "be"
+ elif text[num] == "my":
+ text[num] = "one's"
+
+ # recombine word
+ new_text = ''
+ for num in range(len(text)):
+ if num < len(text) - 1:
+ new_text += text[num] + " "
+ else:
+ new_text += text[num]
+ return new_text
+# VERB EDIT
+
+
+# PARTICIPLE EDIT
+# # # # # # # # # #
+def participle_edit(text,first):
+ text = list(text)
+ new_text = ''
+ for num in range(len(text)):
+ if text[num] == chr(160):
+ text[num] = chr(32)
+ new_text += text[num]
+ text = new_text
+ text = re.split(",|;|:",text)
+
+ offset = 0
+ string_bank = ['having been','having']
+ for i in range(len(text)):
+ i = i - offset
+ for string in string_bank:
+ if string in text[i]:
+ cut = text[i][text[i].find(string + " ") + len(string) + 1:].strip('. ')
+ if cut in text or " " + cut in text:
+ del text[i]
+ offset += 1
+ break
+
+ for num in range(len(text)):
+ if 'which is to be' in text[num] and not first:
+ #print(text[num])
+ cut = text[num].find('to be ') + 6
+ text[num] = text[num][cut:]
+ #print(text[num])
+ text[num] = remove_or(text[num])
+ elif 'which is to be' in text[num]:
+ first = False
+ text[num] = remove_or(text[num])
+
+
+ new_text = ''
+ for num in range(len(text)):
+ if num < len(text) - 1:
+ new_text += text[num].strip() + ", "
+ else:
+ new_text += text[num].strip()
+ return new_text, first
+# END PARTICPLE EDIT
+
+# COPY WORD
+# # # # # # # # # # # # #
+def copy_word(fetch_word,new_word,language):
+
+ # Declare components of new_word
+ new_word['heading'] = None
+ entries = []
+ entry = {}
+ partOfSpeech = []
+ principleParts = []
+ simpleParts = []
+ defs = []
+ roots_list = []
+
+ # for Loop LEVEL ONE, may contain empty 'definitions'
+ for outer in range(len(fetch_word)):
+
+ if fetch_word[outer]['etymology'] != '':
+ etymology = fetch_word[outer]['etymology']
+ else:
+ etymology = ''
+
+ # If not empty...
+ if fetch_word[outer]['definitions'] == []:
+ principleParts = simpleParts = partOfSpeech = '*blank definition*'
+ # Create new entry
+ entry['partOfSpeech'] = partOfSpeech
+ entry['principleParts'] = principleParts
+ entry['simpleParts'] = simpleParts
+ entry['defs'] = []
+ entry['etymology'] = etymology
+
+ # append entry to entries
+ entries.append(entry)
+
+ # reset entry to blank dict
+ entry = {}
+ else:
+ # for Loop LEVEL TWO, copy info into new word components
+ for middle in range(len(fetch_word[outer]['definitions'])):
+
+ # copy definitions text list into new list with shorter name
+ text = fetch_word[outer]['definitions'][middle]['text']
+
+ # capture heading (only one needed per word)
+ if new_word['heading'] == None:
+ # heading should have same number of characters as handle
+ # compare de-macroned version of text[0] with handle
+ # if text[0] starts with something else; heading will just be handle
+ if unidecode(text[0][:len(new_word['handle'])]) != new_word['handle']:
+ new_word['heading'] = new_word['handle']
+ else:
+ # should be the same number of character as handle
+ new_word['heading'] = text[middle][:len(new_word['handle'])]
+
+ # capture part of speech
+ partOfSpeech = fetch_word[outer]['definitions'][middle]['partOfSpeech']
+
+ # How many lines in the definition (including principal parts)
+ num_entries = len(text)
+
+ # for Loop LEVEL THREE, loop through text[:] to copy definitions
+ first = True
+ for inner in range(num_entries):
+
+ # Copy definition
+ text = fetch_word[outer]['definitions'][middle]['text'][inner]
+
+ # Capture principal parts (first entry in ^ 'text')
+ if inner == 0:
+ principleParts = text
+ # call get_simple to simplify principle parts, remove extraneous words
+ simpleParts = principleParts #get_simple(partOfSpeech,principleParts,new_word['heading'],language)
+
+ # Appends definitions to definitions componant
+ else:
+ if partOfSpeech == 'verb':
+ text = verb_edit(text)
+
+ if partOfSpeech == 'participle':
+ text, first = participle_edit(text,first)
+
+
+ defs.append(text.strip(".").replace(":",";"))
+
+ # check if entry is a form of another main entry
+ roots_list = find_root(roots_list,defs,etymology)
+
+ # Create new entry
+ entry['partOfSpeech'] = partOfSpeech
+ entry['principleParts'] = principleParts
+ entry['simpleParts'] = simpleParts
+ entry['defs'] = defs
+ entry['etymology'] = etymology
+
+ # reset defs to empty list
+ defs = []
+
+ # append entry to entries
+ entries.append(entry)
+
+ # reset entry to blank dict
+ entry = {}
+
+ # Back to Loop LEVEL ONE
+
+ # When Loop LEVEL ONE has finished all iterations
+
+ # assign entries to new_word
+ new_word['entries'] = entries
+
+ if roots_list:
+ new_word['roots'] = roots_list
+
+ return new_word
+# END COPY WORD
+
+
+# FIND ROOT
+# # # # # # # # # # # # # # # # #
+def find_root(roots_list,text,etymology):
+
+ test = False
+
+
+ trial_list = [copy.deepcopy(etymology)] + copy.deepcopy(text) if etymology else copy.deepcopy(text)
+ trial_list = chop_parens(trial_list)
+
+ if test:
+ print(trial_list)
+
+
+ word_bank = ['first-person','second-person','third-person','singular',
+ 'plural','indicative','imperative','infinitive','subjunctive','active','passive',
+ 'present','future','perfect','imperfect','pluperfect','participle',
+ 'masculine','feminine','neuter','common','nominative','comparative','degree',
+ 'genitive','dative','accusative','ablative','locative','vocative',
+ 'gerund','gerundive','inflection','supine','alternative','archaic','form','of','from'
+ ]
+ for index in range(len(trial_list)):
+
+ if 'participle of' in trial_list[index]:
+ if test:
+ print(trial_list[index])
+ trial_list[index] = trial_list[index][trial_list[index].find('participle of'):]
+ if test:
+ print(trial_list[index])
+ trial_list[index] = trial_list[index].split()
+ trial_list[index].remove('participle')
+ trial_list[index].remove('of')
+ if test:
+ print(trial_list[index])
+ roots_list.append(trial_list[index][0].strip(".,; "))
+ if test:
+ print(trial_list[index][0])
+ continue
+
+ trial_list[index] = trial_list[index].strip(';, ')
+ if ',' in trial_list[index] or ';' in trial_list[index]:
+ if test:
+ print("Continue 1")
+ continue
+
+
+
+
+
+ string = trial_list[index]
+ string = string.split(' ')
+ if len(string) == 1:
+ if test:
+ print("Continue 2")
+ continue
+
+ offset = 0
+ for index in range(len(string)):
+ index = index - offset
+ string[index] = string[index].strip("().")
+ string[index] = string[index].lower()
+ if '/' in string[index]:
+ string.extend(string[index].split('/'))
+ del string[index]
+ offset += 1
+
+
+ for word in word_bank:
+ if test:
+ print(F"{word} {string}")
+ if word in string:
+ if test:
+ print(f"{word} removed")
+ string.remove(word)
+
+ string[0] = string[0].strip(".,:;\n")
+
+ if len(string) == 1 and string[0] not in roots_list:
+ if test:
+ print(f"{string[0]} being added to Roots")
+ roots_list.append(string[0])
+ if test:
+ print("Roots test completed")
+ return roots_list
+# END FIND ROOT
+
+
+# GET TAGS
+# # # # # # # #
+def getTags(tags=set(),mode='',master_list=[]):
+
+ # Whole function contained in loop
+ while True:
+
+ # flag if tags already in place
+ if tags:
+
+ # create list of tags
+ tag_string = ", ".join(f"'{tag}'" for tag in tags)
+
+ # Print list with appropriate commas
+ if mode:
+ print(f"\n{mode.title()} tags: {tag_string}")
+ else:
+ print(f"\nCurrent tags: {tag_string}")
+
+ if mode:
+ string = mode.title() + " "
+ else:
+ string = ''
+
+ # Display options
+ options = {
+ '0':f"{string}Tag Options:\n>'0' to finish\n"}
+ if mode == '':
+ options.update({'1':">'1' to add a new tag\n"})
+ options.update({'2':">'2' to choose from a list of all tags\n"})
+ # only display if tags not empty
+ if tags:
+ options.update({'3':">'3' to Remove\n",
+ '4':">'4' to clear all\n"})
+ if master_list:
+ options.update({})
+ user_input = get_selection.get_selection(options)
+
+ # Option to finish, return to calling function
+ if user_input == '0':
+ return tags
+
+ # Option to add new tag
+ elif user_input == '1':
+ new_tag = input("Enter new tag: ")
+ tags.add(new_tag)
+ # Option to remove tag
+
+ elif user_input == '3':
+ options = {'0':"Select the tag you want to remove ('0' to go back)\n"}
+ tags_list = list(tags) # convert set to list
+ for index in range(len(tags_list)):
+ options[f"{index+1}"] = f"{index + 1}. {tags_list[index]}\n"
+ user_input = get_selection.get_selection(options)
+
+ if user_input != '0':
+ del tags_list[int(user_input) - 1]
+ tags = set(tags_list) # convert list back to set
+
+
+ # Option to clear all tags
+ elif user_input.lower() == '4':
+ tags = set()
+
+ # option to choose from master list
+ elif user_input.lower() == '2':
+ exit_choose = False
+ # delete all redundant entries
+ offset = 0
+ for index in range(len(master_list)):
+ if master_list[index - offset] in tags:
+ del master_list[index - offset]
+ offset += 1
+
+ # loop for user selections
+ while not exit_choose:
+ options = {}
+ for index in range(len(master_list)):
+ options[f"{index+1}"] = f"{index + 1}. {master_list[index]}\n"
+ options.update({'0':"Select the tag you want to add to your current tags\n"})
+ options.update({'00':"('0' to go back, '00' to finish)\n"})
+ user_input = get_selection.get_selection(options)
+
+ if user_input == '0':
+ exit_choose = True
+ elif user_input == '00':
+ return tags
+ else:
+ tags.add(master_list[int(user_input) - 1])
+ del master_list[int(user_input) - 1]
+ tag_string = ", ".join(f"'{tag}'" for tag in tags)
+ if mode == 'filter':
+ print(f"Filter by tags: {tag_string}")
+ else:
+ print(f"Current tags: {tag_string}")
+# END GET TAGS
+
+
+# GET MASTER LIST
+# # # # # # # # # #
+def get_master_list(current_dict):
+ master_list = []
+ # get list of all unique tags in current dictionary
+ for word in current_dict['definitions']:
+ for tag in word['tags']:
+ if tag not in master_list:
+ master_list.append(tag)
+ return master_list
+# END GET MASTER LIST
diff --git a/word_print_edit.py b/word_print_edit.py
new file mode 100644
index 0000000..d717ba8
--- /dev/null
+++ b/word_print_edit.py
@@ -0,0 +1,381 @@
+
+'''
+Description:
+
+ edit entries:
+ options within word to create, delete, move and modify entries
+
+ select entries:
+ allows user to choose an entry based on letter indices
+ returns selection as the number index of selected entry in entries list
+
+ print entries:
+ print all entries of a word including part of speech
+ option to include capital letter next to part of speech begining each entry
+'''
+import pickle
+from unidecode import unidecode
+from copy import deepcopy
+import word_methods
+import edit_entry
+import create_word
+from get_selection import get_selection, clear_screen
+import parser_shell
+import load_dict
+from pyfiglet import figlet_format
+
+# EDIT ENTRIES
+# # # # # # # # # # # #
+def edit_entries(new_word,current_dict,t):
+ language = current_dict['language']
+ # save confirm choice string used in multiple places
+ confirm_str = "'1' to confirm, any other key to cancel: "
+ entry_string = ''
+ # rest of function contained in loop
+ while True:
+
+ # flag if only one entry exists
+ if len(new_word['entries']) <= 1:
+ single_entry = True
+ else:
+ single_entry = False
+
+ entry_string = get_entry_string(new_word['entries'])
+
+ # get user selection
+ options = {
+ '1':f"\n===================================================\n'{new_word['heading']}' Options:\n>'1' Edit Entry\n",
+ '2':">'2' Create New Entry\n"}
+ if not single_entry:
+ options.update({
+ '3':">'3' Move Entry\n",
+ '4':">'4' Delete Entry\n"})
+ #'5':">'5' Merge Entries\n"})
+ if 'template' in new_word:
+ options.update({'reset':">'reset' to reset template tag\n"})
+ options.update({
+ 'tags':">'tags' to modify tags\n",
+ 'add':">'add' to add another word\n",
+ 'head':"'head' to change heading\n",
+ #'split':"'split' to create sub-cards\n",
+ '0':">'0' to finish edit\n",'00':">'00' to finish and save\n",'verb':''})
+ clear_screen()
+ user_input = get_selection(options,entry_string)
+
+
+ # Option to exit, only way to end loop
+ if user_input == '0':
+ return new_word, False
+
+ if user_input == '00':
+ return new_word, True
+
+ # edit tags option
+ if user_input.lower() == 'tags':
+ master_list = word_methods.get_master_list(current_dict)
+ new_word['tags'] = word_methods.getTags(new_word['tags'],'',master_list)
+
+ if user_input.lower() == 'reset':
+ del new_word['template']
+
+ # Options to modify entry, then repeat loop
+ elif user_input == '1':
+ # selection needed only for multiple entries
+ if single_entry:
+ new_word['entries'][0], finish_and_save = edit_entry.edit_entry(new_word['entries'][0],new_word)
+ if finish_and_save:
+ return new_word, True
+ else:
+ # request user selection with appropriate message
+ message = '===================================================\nEnter the letter of the entry you want to modify.'
+ selection = select_entry(new_word['entries'],message)
+
+ # unless modify is aborted, call edit_entry, repeat loop when done
+ if selection != None:
+ clear_screen()
+ new_word['entries'][selection], finish_and_save = edit_entry.edit_entry(new_word['entries'][selection],new_word)
+ if finish_and_save:
+ return new_word, True
+
+ # Option to create new entry, then repeat loop
+ elif user_input == '2':
+ new_word, result = create_word.create_entry(new_word)
+
+ # Option to move entry
+ elif user_input == '3' and not single_entry:
+ if len(new_word['entries']) == 2:
+ new_word['entries'] = edit_entry.move_entries(new_word['entries'],1,0)
+ else:
+ exit_inner_loop = False
+ while not exit_inner_loop:
+ # request user selection with appropriate message
+ message = "\n===================================================\nEnter the letter of the entry you want to move."
+ selection = select_entry(new_word['entries'],message)
+
+ # unless move is aborted, proceed to STEP TWO
+ if selection != None:
+ # request user selection with appropriate message
+ message = f"\n===================================================\nMove {chr(selection + 65)} to what position?"
+ new_position = select_entry(new_word['entries'],message)
+
+ # unless move is aborted, confirm requested change
+ if new_position != None:
+ new_word['entries'] = edit_entry.move_entries(new_word['entries'],selection,new_position)
+ else:
+ exit_inner_loop = True
+
+ elif user_input.lower() == 'add':
+ print("'1' to look up word, '2' to create new entry")
+ user_input = input(": ")
+ if user_input == '1':
+ new_word = word_combo(new_word,t,current_dict['language'])
+ else:
+ new_entry, result = create_word.create_entry(new_word)
+
+ # Option to delete
+ elif user_input == '4' and not single_entry:
+ exit_inner_loop = False
+ while not exit_inner_loop:
+ # request user selection with appropriate message
+ message = '===================================================\nEnter the letter of the entry you want to delete.'
+ selection = select_entry(new_word['entries'],message)
+
+ # if delete not aborted, confirm requested deletion
+ if selection != None:
+ # Confirm deletion
+ print(f"\nDelete entry {chr(selection+65)}?")
+ user_input = input(confirm_str)
+
+ # if confirmed, delete entry / either way, repeat loop when done
+ if user_input == '1':
+ del new_word['entries'][selection]
+ else:
+ exit_inner_loop = True
+ if len(new_word['entries']) == 1:
+ exit_inner_loop = single_entry = True
+
+ elif user_input == '5' and not single_entry:
+ exit_inner_loop = False
+ while not exit_inner_loop:
+ # request user selection
+ # request user selection with appropriate message
+ message = '===================================================\nEnter the letter of the entry you want to merge to.'
+ s1 = select_entry(new_word['entries'],message)
+
+ if s1 != None:
+ # request user selection with appropriate message
+ message = f'===================================================\nEnter the letter of the entry you want to merge with entry {chr(s1 + 65)}.'
+ s2 = select_entry(new_word['entries'],message)
+
+ if s2 != None:
+ new_word['entries'][s1]['defs'].extend(new_word['entries'][s2]['defs'])
+
+ print(f"\nChange principle parts \nfrom: {new_word['entries'][s1]['simpleParts']}")
+ print(f"to: {new_word['entries'][s2]['simpleParts']}\n")
+ user_input = input("'1' to confirm, any other key for no: ")
+
+ if user_input == '1':
+ new_word['entries'][s1]['simpleParts'] = new_word['entries'][s2]['simpleParts']
+
+ del new_word['entries'][s2]
+ exit_inner_loop = True
+ else:
+ exit_inner_loop = True
+
+ # Test if heading should be changed
+ if new_word['heading'] != new_word['entries'][0]['simpleParts'][:len(new_word['heading'])]:
+ print(f"Change heading from {new_word['heading']} to {new_word['entries'][0]['simpleParts'][:len(new_word['heading'])]}?")
+ user_input = input("'1' to confirm, any other key for no: ")
+
+ if user_input == '1':
+ new_word['heading'] = new_word['entries'][0]['simpleParts'][:len(new_word['heading'])]
+ new_word['handle'] = unidecode(new_word['heading'])
+
+ elif user_input == 'head':
+ print("\nEnter your new heading ('0' to go back) (ā, ē, ī, ō, ū)")
+ new_definition = input(': ')
+
+ if new_definition != '0':
+ new_word['heading'] = new_definition
+ new_word['handle'] = unidecode(new_word['heading'])
+
+ elif user_input == 'split':
+ split_word(new_word,current_dict)
+
+ elif user_input == 'verb':
+ for i in new_word['entries']:
+ i['partOfSpeech'] = 'verb'
+
+
+# END EDIT ENTRIES
+
+def flatten(word):
+ for i in word['entries']:
+ for z in i['defs']:
+ z['gloss'] = z['gloss'].lower()
+
+def split_word(word,current_dict):
+ count = 1
+ splits = []
+ while True:
+ new_split = {}
+ print(word['heading'])
+ print(word['entries'][0]['simpleParts'])
+ print(f"Enter Split {count} heading ('0' to stop)")
+ user_input = input(": ")
+ if user_input == '0':
+ return
+ new_split['heading'] = new_split['handle'] = '' + user_input
+ new_split['tags'] = []
+ new_split['entries'] = [{'simpleParts':user_input,'principleParts':user_input,'partOfSpeech':'split','defs':[]}]
+ for entry in word['entries']:
+ while True:
+ print(f"Split {count}:")
+ if new_split['entries'][0]['defs']:
+ edit_entry.print_entry(new_split['entries'][0])
+ else:
+ print("\nENTRY:")
+ print("******\n")
+ print(f"{new_split['entries'][0]['partOfSpeech']}\n")
+ print(new_split['entries'][0]['simpleParts'])
+ selection = edit_entry.select_definition(entry,f"Choose definition to add to split {count} ('0' for next):")
+ if selection == None:
+ break
+ if type(selection) == list:
+ for i in range(selection[0],selection[1]+1):
+ new_split['entries'][0]['defs'].append(entry['defs'][i])
+ else:
+ new_split['entries'][0]['defs'].append(entry['defs'][selection])
+ edit_entry.print_entry(new_split['entries'][0])
+ while True:
+ print(f"Save split {count}? ('1' save, '0' to discard)")
+ user_input = input(": ")
+ if user_input == '0':
+ break
+ elif user_input == '1':
+ splits.append(deepcopy(new_split))
+ break
+ else:
+ print("Invalid entry")
+ while True:
+ print("Creat another split? ('1' to continue, '0' to finish)")
+ user_input = input(": ")
+ if user_input == '0' or user_input == '1':
+ break
+ else:
+ print("Invalid entry")
+ if user_input == '1':
+ count += 1
+ continue
+ elif user_input == '0':
+ break
+ if splits:
+ for split in splits:
+ parser_shell.save_word(split,current_dict)
+ return
+
+
+
+
+# WORD COMBO
+# # # # # # # # # # # # # # #
+def word_combo(new_word,t,lang,search_word=None):
+ letters = []
+ """ Retrieve use selection from dictionary """
+ combo_word = parser_shell.choose_from_trie(t,lang)
+
+ if combo_word == None:
+ return new_word
+ else:
+ if 'roots' in combo_word:
+ new_word['roots'] = combo_word['roots']
+ for index in range(len(combo_word['entries'])):
+ new_word['entries'].append(combo_word['entries'][index])
+
+ if new_word['heading'] != combo_word['heading']:
+ print(f"Change heading from {new_word['heading']} to {combo_word['heading']}?")
+ user_input = input("'1' to confirm, any other key for no: ")
+
+ if user_input == '1':
+ new_word['heading'] = combo_word['heading']
+ new_word['handle'] = combo_word['handle']
+
+ print("NEW COMBINED WORD:\n")
+ print_entries(new_word['entries'])
+ return new_word
+
+# END WORD COMBO
+
+
+# SELECT ENTRY
+# # # # # # # # # # # # # # #
+def select_entry(entries,message):
+ # whole function contained in loop
+ invalid = False
+ while True:
+ # Display entries in 'options mode'
+ print_entries(entries,mode='choice')
+
+ # Print message supplied in function call
+ print(message)
+ print("'0' to go back")
+ if invalid:
+ print('\ninvalid selection\n\n')
+ invalid = False
+ user_input = input(': ')
+
+ # Options to go back, None indicates no selection made
+ if user_input == '0':
+ return None
+
+ # validate user input, should be a single letter
+
+ # Avoid empty string error
+ if len(user_input) == 1:
+
+ # convert to index 'A'=0,'B'=1...
+ user_input = ord(unidecode(user_input.upper())[0])-65
+ # verify input in range
+ if user_input in range(len(entries)):
+ # return valid selection
+ return user_input
+
+ # invalid, repeat loop
+ invalid = True
+# END SELECT ENTRY
+
+def get_entry_string(entries, mode=''):
+ string = ""
+ if mode == 'choice':
+ string += figlet_format("ENTRY OPTIONS:",font='cybermedium',width=150)
+ string += "**************\n\n"
+ else:
+ string += figlet_format("CURRENT WORD:",font='cybermedium',width=150)
+ string += "*************************\n\n"
+
+ # Loop to print entries
+ for index in range(len(entries)):
+
+ # mode '1' print capital letters new to part of speech for each entry
+ if mode == 'choice':
+ c = chr(index + 65)
+ string += f"\n({c}). "
+
+ # assign definitions to shorter name
+ if mode == 'choice':
+ string += edit_entry.get_entry(entries[index],'choice',trunc=True)
+ else:
+ string += edit_entry.get_entry(entries[index],'plain',trunc=True)
+ string += '\n'
+ # print new line when finished
+ string = string.strip("\n")
+ return string
+
+
+# PRINT ENTRIES
+# # # # # # # # # # # # # # #
+def print_entries(entries,mode=''):
+ # mode 1 is options mode
+ clear_screen()
+ print(get_entry_string(entries,mode))
+# END PRINT ENTRIES