diff --git a/README.md b/README.md
index 5a9fcff..5f9afdd 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
 # Word-Hoarder
-A program for creating a searchable local language dictionary based (mainly) on dumped wiktionary data. Allows users to collect definitions which can be exported as a machine readable flashcard file. Currently supports Latin, Ancient Greek and Old English.
+A program for creating a searchable local language dictionary based (mainly) on extracted wiktionary data. Allows users to collect definitions which can be exported as a machine readable flashcard file. Currently supports Latin, Ancient Greek and Old English.
 
 ## Parsing Data
-### dump_parser.py
-This module processes wiktionary dump files which can be found at kaikki.org
+### convert_file_utilities.py
+This module processes extracted wiktionary data files which can be found at kaikki.org
 
 <ul><li>https://kaikki.org/dictionary/Latin/</li>
 <li>https://kaikki.org/dictionary/Ancient%20Greek/index.html</li>
@@ -11,7 +11,7 @@ This module processes wiktionary dump files which can be found at kaikki.org
 
 See https://github.com/tatuylonen/wiktextract
 
-The module looks for the files in a subfolder of main directory containing the source files: "dumps_unsorted".
+The module looks for the files in a subfolder of main directory containing the source files: "kaikki_json_files".
 
 The module organizes the data into a standard data structure used in this program.
 
@@ -36,7 +36,7 @@ Definitions are made of standard python data structures.
 <p>Senses:
 {
 "gloss": string containing a word sense you would find in a single line of a definition in a typical dictionary,
-"tags": tags related to a specific word sense such as "Pre-classical" or "transitive"
+"tags": [tags related to a specific word sense such as "Pre-classical" or "transitive"]
 }</p>
 
 ### dictionary_LSJ.py and dictionary_Middle_Liddell.py
diff --git a/src/combine_entries.py b/src/combine_entries.py
deleted file mode 100644
index 8b72030..0000000
--- a/src/combine_entries.py
+++ /dev/null
@@ -1,63 +0,0 @@
-
-import pickle
-from load_dict import change_path
-
-change_path('dictionaries')
-with open('new_dictionary_unjoined.txt','rb') as file:
-	dictionary = pickle.load(file)
-
-alpha = {}
-for i in range(0,26):
-	alpha[chr(i+97)] = 0
-for i in range(len(dictionary['definitions'])):
-	if dictionary['definitions'][i]['handle'][0].lower() in alpha:
-		alpha[dictionary['definitions'][i]['handle'][0].lower()] = i
-
-'''
-prev = 0
-counter = 0
-for key in alpha:
-	print(f"processing {key}s")
-	for i in range(prev,alpha[key]):
-		if dictionary['definitions'][i] in dictionary['definitions'][i + 1:i + 10]:
-			dictionary['definitions'][i]['tags'].append('DUPE')
-	prev = alpha[key]
-	print(f"{key}s completed")
-
-offset = 0
-for i in range(len(dictionary['definitions'])):
-	if "DUPE" in dictionary['definitions'][i - offset]['tags']:
-		print(f"deleting {dictionary['definitions'][i - offset]['handle']}")
-		del dictionary['definitions'][i - offset]
-		offset += 1
-'''	
-prev = 0
-counter = 0
-comp = ''
-for key in alpha:
-	handles = []
-	print(f"processing {key}s")
-	for i in range(prev,alpha[key]):
-		if comp == dictionary['definitions'][i]:
-			continue
-		else:
-			comp = dictionary['definitions'][i]
-		for j in range(1,len(dictionary['definitions'][i + 1:i+20])):
-			if dictionary['definitions'][i + j]['handle'] == dictionary['definitions'][i]['handle']:
-				print(f"i={i},j={j}; adding {dictionary['definitions'][i]['handle']} to {dictionary['definitions'][i + j]['handle']}")
-				dictionary['definitions'][i]['entries'].extend(dictionary['definitions'][i + j]['entries'])
-				dictionary['definitions'][i]['roots'].extend(dictionary['definitions'][i + j]['roots'])
-				dictionary['definitions'][i + j]['tags'].append('DUPE')
-	prev = alpha[key]
-	print(f"{key}s completed")
-
-offset = 0
-for i in range(len(dictionary['definitions'])):
-	if "DUPE" in dictionary['definitions'][i - offset]['tags']:
-		print(f"deleting {dictionary['definitions'][i - offset]['handle']}")
-		del dictionary['definitions'][i - offset]
-		offset += 1
-
-
-with open(dictionary['file'],mode = 'wb') as openFile:
-	pickle.dump(dictionary, openFile)
diff --git a/src/dump_parser.py b/src/convert_file_utilities.py
similarity index 81%
rename from src/dump_parser.py
rename to src/convert_file_utilities.py
index 83462ee..cb1f319 100644
--- a/src/dump_parser.py
+++ b/src/convert_file_utilities.py
@@ -10,7 +10,7 @@
 import difflib
 
 import parser_shell
-from load_dict import change_path, pick_language
+from load_dict import change_path, pick_language, KAIKKI_JSON_FILES, SUPPLEMENTARY_LANGUAGE_FILES
 import edit_all
 from get_selection import get_selection
 from language_splitter import split_language
@@ -41,7 +41,9 @@ def filter_tags(gloss_parts, existing_tags, Test):
 	return new_tags, gloss_parts
 
 def paren_cut(gloss, tags):
-
+	'''	Attempts to cut a parenthetical from the beginning of a sense if it 
+		duplicates the tags. 
+	'''
 	if gloss[0] != "(":
 		return gloss, tags
 
@@ -59,7 +61,10 @@ def paren_cut(gloss, tags):
 
 
 
-def add_def(senses,new_gloss,gloss_tags):
+def add_def(senses, new_gloss, gloss_tags):
+	'''	Attempts to read item from line 'senses' in json file to find 
+		all non-duplicate glosses and collect tags corresponding to each gloss
+	'''
 	if ")" in new_gloss:
 		for d in senses:
 			if new_gloss[new_gloss.find(")") + 2:] == d['gloss']:
@@ -81,6 +86,9 @@ def add_def(senses,new_gloss,gloss_tags):
 		senses.append({'gloss':new_gloss,'tags':copy.deepcopy(gloss_tags)})
 
 def create_senses(line_senses, tag_list):
+	'''	Iterate through line senses and collect all non-duplicate senses 
+		and tags corresponding to each sense. 
+	'''
 	senses = []
 	dupe_list = []
 
@@ -132,14 +140,21 @@ def process_glosses(glosses, gloss_tags):
 	return senses
 
 def get_file_selection(Test, test_file, test_language):
-	change_path('dumps_unsorted')
+	'''	User input function to select from avialable kaikki files
+	'''
+	change_path(KAIKKI_JSON_FILES)
+
 	if Test:
 		return test_file, test_language
+
 	else:
+		# fine all .json files in KAIKKI_JSON_FILES
 		myFiles = glob.glob('*.json')
 		if myFiles == []:
 			print("\nSorry no saved dictionaries")
 			return None, None
+
+		# prompt user to choose a file
 		else:
 			options = {'0':f"\nChoose from the following files: (0 to go back)\n"}
 			for index in range(len(myFiles)):
@@ -150,10 +165,15 @@ def get_file_selection(Test, test_file, test_language):
 				return None, None
 			else:
 				file = myFiles[int(user_input)-1]
+
+			# user must also tell the program what the language is
 			language = pick_language()
+
 		return file, language
 
 def print_debug_info(line, counter):
+	'''	Function for viewing unprocessed json data 
+	'''
 	print('\n')
 	print(f"\tline: {counter}, word: {line['word']}")
 	print("WORD ITEMS >>>>>>>>>>>>>>")
@@ -164,37 +184,56 @@ def print_debug_info(line, counter):
 		print(item)
 
 def handle_pos(line):
+	'''	Matches json pos abbreviations with those used in
+		word-hoarder definitions.
+	'''
 	pos_mapping = {
 		'adv': 'adverb',
 		'adj': 'adjective',
 		'prep': 'preposition',
 		'intj': 'interjection'
 	}
-
 	pos = line['pos']
 	line['pos'] = pos_mapping.get(pos, pos)
 	return line['pos']
 
 def handle_senses(line,tag_list):
+	''' json file contains edge cases where expected part of the
+		line entry are blank or missing.
+	'''
 	if 'tags' in line['senses'][0]:
+
 		tag = line['senses'][0]['tags']
+
+		# the dictionary may contain a few word with 'no-senses' etc. as 
+		# the only sense. The user should still have these available because
+		# it is easier to modify than creating a new definition from scratch.
 		if 'no-senses' in tag or 'no-gloss' in tag or 'empty-gloss' in tag:
 			if isinstance(tag,list):
 				return [{'gloss': ", ".join(tag), 'tags': []}]
 			else:
 				return [{'gloss': tag, 'tags': []}]
 		else:
+			
+			# normal case when the line has a full complement of senses
 			return create_senses(line['senses'], tag_list)
 	else:
+		# line may have senses but missing the 'tag' key
 		return create_senses(line['senses'], tag_list)
 
 def handle_etymology(line):
+	'''	Check is 'etymology' key is present
+	'''
 	if 'etymology_text' in line:
 		return line['etymology_text']
 	else:
 		return ''
 
 def handle_parts(line,get_simple=None):
+	'''	Will attempt to convert information in json line to simpleParts 
+		if the necessary ingrediants are present. Otherwise defaults to 
+		line['word']	
+	'''
 	if get_simple:
 		return get_simple(line['pos'], line['head_templates'][0]['expansion'], line['word']) if 'head_templates' in line else line['word']
 	else:
@@ -202,6 +241,8 @@ def handle_parts(line,get_simple=None):
 
 
 def handle_word_entry(line,tag_list,get_simple=None):
+	''' Retrieve data from json line and assign to word-hoarder entry
+	'''
 	return {
 		'partOfSpeech': handle_pos(line),
 		'principleParts': line['head_templates'][0]['expansion'] if 'head_templates' in line else line['word'],
@@ -213,6 +254,9 @@ def handle_word_entry(line,tag_list,get_simple=None):
 
 
 def handle_word(line,tag_list,language,get_simple=None):
+	''' Retrieve data from json line and assign to word-hoarder definition.
+		Definitions have only one entry until de-duplication.
+	'''
 	return {
 		'heading': line['word'],
 		'handle': unidecode(line['word']) if language in ["Latin", "Italian"] else line['word'],
@@ -222,6 +266,9 @@ def handle_word(line,tag_list,language,get_simple=None):
 	}
 
 def ui_template(new_dictionary,dict_str,shrt_str,cite,cite_2='',dict_f=""):
+	'''	Standard ui prompts to add supplemental dictionaries and display
+		information about data sources.
+	'''
 	user_input = input(f"\nAdd definitiions from: \"{dict_str}\"?"\
 		+ "\nType 'y' to add definitions, Press 'Enter' to continue: " )
 		
@@ -234,6 +281,8 @@ def ui_template(new_dictionary,dict_str,shrt_str,cite,cite_2='',dict_f=""):
 		thank(dict_str,shrt_str,n,cite)
 
 def thank(dict_str,shrt_str,length,cite,cite_2='',dict_f=""):
+	'''	Standard prompt to display attribution/information about data sources.
+	'''
 	print(f"\nYour dictionary now contains ( {length:,} ) unique definitions after adding {shrt_str}.")
 	print(f"Data files courtesy of {cite}.",end='')
 	if cite_2:
@@ -245,6 +294,9 @@ def thank(dict_str,shrt_str,length,cite,cite_2='',dict_f=""):
 		input(f"\n(Press 'Enter' to continue)")
 
 def parse_lines(input_file,tag_list,language,get_simple=None):
+	''' Receives an open kaikk.org json input_file and reads lines
+		to decode json objects into simplified word hoarder data structure.
+	'''
 	definitions_dict = {}
 	counter = 0
 	for line in input_file:
@@ -285,28 +337,14 @@ def parse_lines(input_file,tag_list,language,get_simple=None):
 	thank(dict_str,shrt_str,n,cite,cite_2)
 	return definitions
 
-# duplicate of a function found in tables.py
-'''
-def replace_greek(word):
-	alt_letters = {
-	'Ἀ':'Α',
-	'ά':'α', 'ἀ':'α', 'ἄ':'α', 'ἅ':'α', 'ἆ':'α', 'ᾰ':'α', 'ᾱ':'α', 'ᾴ':'α',
-	'έ':'ε', 'ἐ':'ε', 'ἑ':'ε', 'ἔ':'ε', 'ἕ':'ε', 
-	'ή':'η','ἡ':'η', 'ἤ':'η', 'ἥ':'η', 'ῆ':'η',
-	'ί':'ι','ἰ':'ι', 'ἱ':'ι', 'ἴ':'ι', 'ἵ':'ι', 'ἶ':'ι', 'ῐ':'ι', 'ῑ':'ι', 'ῖ':'ι',
-	'ό':'ο','ὀ':'ο', 'ὁ':'ο', 'ὄ':'ο', 'ὅ':'ο',
-	'ῥ':'ρ',
-	'ύ':'υ','ὐ':'υ', 'ὑ':'υ', 'ὔ':'υ', 'ὕ':'υ', 'ὖ':'υ', 'ὗ':'υ','ῠ':'υ', 'ῡ':'υ', 'ῦ':'υ', 
-	'ώ':'ω', 'ὧ':'ω','ῶ':'ω', 'ῷ':'ω'
-	}
-	for x in word:
-		if x in alt_letters:
-			word = word.replace(x,alt_letters[x])
-	return word
-'''
 
-def sort_dump():
+def convert_files():
+	'''	Converts kaikki.org json files to smaller files containing
+		just the necessary information for students looking for quick 
+		reference. 
+	'''
 
+	# This module can be run independently for debugging purposes
 	print_mode = Test
 	save_mode = not Test
 	test_language = 'Ancient Greek'
@@ -314,11 +352,12 @@ def sort_dump():
 
 	# Load list of tags that are not descriptive/overly general
 	try:
-		change_path('texts')
+		change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 		with open('ignore_tags.txt','r') as f:
 			tag_list = json.load(f)
+
 	except FileNotFoundError:
-		print("'ignore_tags.txt' not found in 'texts' directory.")
+		print(f"'ignore_tags.txt' not found in '{SUPPLEMENTARY_LANGUAGE_FILES}' directory.")
 		input("Enter to continue")
 		tag_list = []
 
@@ -333,23 +372,25 @@ def sort_dump():
 	else:
 		simple = None
 
+	# create file string and initialize new dictionary
 	sorted_file = language.replace(" ", '') + "Dump.txt"
 	new_dictionary = {'definitions':[], 'file': sorted_file, 'language':language}
 
 	print(f"Parsing {file}")
 	
 	# attempt to parse kaikki.org json file
-	change_path('dumps_unsorted')
+	change_path(KAIKKI_JSON_FILES)
 	try:
 		with open(file, 'r') as input_file:
 			new_dictionary['definitions'] = parse_lines(input_file, tag_list,language,simple)
 
 		# save a list of all tags that were encountered
-		change_path('texts')
+		change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 		with open(language + '_new_tag_list.txt', mode='w') as f:
 			json.dump(tag_list, f)
+
 	except FileNotFoundError:
-		print(f"'{file}' not found in 'dumps_unsorted' directory")
+		print(f"'{file}' not found in '{KAIKKI_JSON_FILES}' directory")
 		input("Enter to continue")
 		return
 
@@ -388,8 +429,6 @@ def sort_dump():
 		from dictionary_MLJohnson import Johnson_OED
 		ui_template(new_dictionary,dict_str,shrt_str,cite,cite_2,Johnson_OED)	
 
-	# Last few sections may leave CWD == 'texts', change to 'dumps_sorted'
-	change_path('dumps_sorted')
 
 	# sort by handle string
 	new_dictionary['definitions'].sort(key=lambda item: item.get('handle').lower())
diff --git a/src/create_word.py b/src/create_word.py
index 2eae3be..d297c05 100644
--- a/src/create_word.py
+++ b/src/create_word.py
@@ -3,7 +3,7 @@
 
 	create word:
 		create a new word based on user input
-		intended to be used if valid latin word cannot be retrieved by wiktionary parser
+		intended to be used if valid word cannot be retrieved from language dictionary
 
 	create entry:
 		create a new entry within a word
@@ -49,11 +49,11 @@ def create_word(current_dict,tags):
 	new_word['entries'][0], dummy = edit_entry.edit_entry(new_word['entries'][0],new_word)
 
 	# call word options, from here return
-	load_dict.change_path('dumps_sorted')
+	load_dict.change_path(SORTED_LANGUAGE_FILES)
 	if current_dict['language'] == 'Latin' or current_dict['language'] == "Ancient Greek":
 		wiki_dump = parser_shell.load_big_language(new_word['heading'][0],current_dict['language'])
 	else:
-		wiki_dump = parser_shell.load_dump(current_dict['language'])
+		wiki_dump = parser_shell.load_sorted_language(current_dict['language'])
 	parser_shell.save_word(new_word,wiki_dump,2)
 	current_dict = parser_shell.save_word(new_word,current_dict)
 	return current_dict
diff --git a/src/dict_utilities.py b/src/dict_utilities.py
deleted file mode 100644
index 1a278e1..0000000
--- a/src/dict_utilities.py
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-# Print Progress
-def printpr(counter, modulo=10000):
-	if counter % modulo == 0:
-		print(".",end='',flush=True)
-	if counter % (modulo*100) == 0:
-		print(f' {counter:,} lines parsed',flush=True)
-
-
-
diff --git a/src/dictionary_LSJ.py b/src/dictionary_LSJ.py
index 952f06e..effa8c1 100644
--- a/src/dictionary_LSJ.py
+++ b/src/dictionary_LSJ.py
@@ -1,219 +1,60 @@
 
+from load_dict import change_path, SUPPLEMENTARY_LANGUAGE_FILES
+from perseus_xml_utilities import printpr, cut_text, translate_greek, smart_join, configure_parts, process_entry, get_def
 
-import parser_shell
-from load_dict import change_path
-from copy import deepcopy
-import edit_all
-import pickle
-import beta_code
-from language_splitter import split_language
-from dict_utilities import printpr
-
-
-interval = 1000
-level = 0
-start = (interval * level)
-stop = (interval) * (level + 1)
-debug_print = False
 progress_print = True
 
-def cut_text(text,start,stop):
-	p = text.find(start) + len(start)
-	text = text[p:]
-	text = text[:text.find(stop)]
-	return text
-
-def translate_greek(text,bold):
-	text = list(text)
-	text = [x for x in text if not x.isnumeric()]
-	text = "".join(text)
-	if bold:
-		return "<b>" + beta_code.beta_code_to_greek(text) + "</b>"
-	else:
-		return beta_code.beta_code_to_greek(text)
-
-
-def smart_join(text):
-	s = ""
-	for i in range(len(text)):
-		if i == 0:
-			s = text[i]
-		else:
-			if s[-1] != " " and s[-1] not in ['('] and text[i][0] != " " and text[i][0] not in [',','.',';',')','?']:
-				s += " " + text[i]
-			else:
-				s += text[i]
-	return s.replace(" .",".").replace(" ,",",").replace(" :",":")
-
-
-def configure_parts(senses):
-	count = 0
-
-	for i in senses[0]['gloss']:
-		if i == "(":
-			count += 1
-
-		if i == ")" and count != 0:
-			count -= 1
-
-		if count < 0:
-			# Error too many )s, unbalanced parens
-			print(senses[0]['gloss'])
-			print(senses[1]['gloss'])
-			break
-
-	if count != 0:
-		parens = 0
-
-		for i in range(len(senses[1]['gloss'])):
-			if senses[1]['gloss'][i] == ")":
-				parens += 1
-
-			if senses[1]['gloss'][i] == "(":
-				parens -= 1
-
-			if parens == count:
-				break
-
-		if i < len(senses[1]['gloss']) - 1:
-			senses[0]['gloss'] = smart_join([senses[0]['gloss'],senses[1]['gloss'][: i + 1]])
-			senses[1]['gloss'] = senses[1]['gloss'][i + 1 :]
-
-			for i in range(len(senses[1]['gloss'])):
-				if senses[1]['gloss'][i].isalpha() or senses[1]['gloss'][i] == "=":
-					break
-			senses[1]['gloss'] = senses[1]['gloss'][i:]
-		else:
-			senses[0]['gloss'] += ")"
-
-	return senses
-
-
-def process_entry(text):
-	definition = {'heading':'',
-				'handle':'',
-				'tags':set(),
-				'entries':[]}
-
-	entry = {'senses':[],
-			'partOfSpeech':'',
-			'principleParts':'',
-			'simpleParts':'',
-			'etymology':''}
-
-	handle = cut_text(text,"key=\"","\"")
-	definition['heading'] = definition['handle'] = translate_greek(handle,False)
-	
-	if debug_print:
-		print("@"*5000 + f"\nheading \"{definition['heading']}\"")
-
-	while text != "":
-		text, senses = get_def(text)
-
-		for x in senses:
-			if debug_print:
-				print(f"definition: {x['gloss']}")
-			entry['senses'].append(deepcopy(x))
-
-	if len(entry['senses']) > 1:
-		entry['senses'] = configure_parts(entry['senses'])
-		entry['simpleParts'] = entry["principleParts"] = entry['senses'][0]['gloss']
-		entry['senses'].pop(0)
-	else:
-		entry['simpleParts'] = entry["principleParts"] = definition['heading']
-
-	definition['entries'].append(deepcopy(entry))
-	definition['tags'].add("LSJ")
-	return definition
-
-def get_def(text):
-	m = 0
-	gloss = []
-	senses = []
-	greek = False
-	candidate_tag = ''
-	while True:
-		pull = text[:text.find("<")]
-		brac = text[text.find("<"):text.find(">")+1]
-		text = text[text.find(">") + 1:]
-
-		if greek and pull != "":
-			pull = translate_greek(pull,True)
-			greek = False
-
-		if 'lang=\"greek\"' in brac:
-			greek = True
-
-		if "<sense" in brac:
-			gloss = smart_join(gloss).strip(",. ")
-			if gloss != "":
-				senses.append({'gloss':gloss,'tags':[]})
-			gloss = []
-
-		if pull != "":
-			gloss.append(deepcopy(pull))
-
-		if brac == "</sense>" or text == "":
-			gloss = smart_join(gloss).strip(",. ")
-			if gloss != "":
-				senses.append({'gloss':gloss,'tags':[]})
-			break
-
-	return text, senses
-
-def extract_dictionary(perseus, dictionary):
-	line_list = []
-	ignition = False
-
-	for line in f.readlines():
-		if "<entryFree" in line:
-			ignition = True
-
-		if ignition:
-			line_list.append(line.strip(" \n\t"))
-
-		if "</entryFree" in line and ignition:
-			line_list.append(line.strip())
-			line_list = "".join(line_list)
-			dictionary['definitions'].append(process_entry(line_list))
-			ignition = False
-			line_list = []
-
-	return dictionary
-
 
 def LSJ(new_dictionary):
-	change_path('texts')
+	''' function for parsing the Liddell-Scott-Jones files. 
+		See readme for info on files.
+	'''
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 	dictionary = {'file':'','definitions':[],"language":''}
 
+	# 27 files total
 	for i in range(1,28):
+
 		try:
-			with open('grc.lsj.perseus-eng' + str(i) + '.txt','r') as f:# ####
+			with open('grc.lsj.perseus-eng' + str(i) + '.txt','r') as f:
+
 				if progress_print:
 					print(f"Parsing '{'grc.lsj.perseus-eng' + str(i) + '.txt:' + chr(39):<28}",end='',flush=True)
 
-				
+				# line list collects the lines the make up an entry for a single word
+				# in this file words can be spread over multiple lines
 				line_list = []
+
+				# flag indicates when the start of a word may have been found
 				ignition = False
+
+				# used to print progress bar
 				counter = 0
+
 				for line in f.readlines():
+
+					# indicates start of a definition
 					if "<entryFree" in line:
 						ignition = True
 
+					# collect lines until end of definition
 					if ignition:
 						line_list.append(line.strip(" \n\t"))
 
+					# close of entry, join lines and pass to process_entry
 					if "</entryFree" in line and ignition:
 						line_list.append(line.strip())
 						line_list = "".join(line_list)
-						dictionary['definitions'].append(process_entry(line_list))
+						dictionary['definitions'].append(process_entry(line_list,tag="LSJ"))
 						ignition = False
 						line_list = []
+
 					counter += 1
 					if progress_print:
 						printpr(counter)
 
 				print(f' {counter:,} lines parsed',flush=True)
+
 		except FileNotFoundError:
 			print(f"'{'grc.lsj.perseus-eng' + str(i) + '.txt'} not found in 'texts' directory")
 
diff --git a/src/dictionary_Lewis.py b/src/dictionary_Lewis.py
index 2d0ee1e..da1a4f2 100644
--- a/src/dictionary_Lewis.py
+++ b/src/dictionary_Lewis.py
@@ -1,7 +1,7 @@
 
 
 import parser_shell
-from load_dict import change_path
+from load_dict import change_path, SUPPLEMENTARY_LANGUAGE_FILES
 from copy import deepcopy
 import edit_all
 import pickle
@@ -194,10 +194,7 @@ def get_senses(entry,sense):
 
 def Lewis(new_dictionary={'definitions':[]}):
 
-
-
-	change_path('texts')
-	change_path('lewis-short-json-master')
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 
 	dictionary = {'file':'','definitions':[],"language":''}
 
diff --git a/src/dictionary_MLJohnson.py b/src/dictionary_MLJohnson.py
index 56af21b..d742df8 100644
--- a/src/dictionary_MLJohnson.py
+++ b/src/dictionary_MLJohnson.py
@@ -1,12 +1,10 @@
 
-
-
-from load_dict import change_path
+from load_dict import change_path, SUPPLEMENTARY_LANGUAGE_FILES
 from copy import deepcopy
 import edit_all
 import pickle
 
-from dict_utilities import printpr
+from perseus_xml_utilities import printpr
 
 interval = 30
 level = 1
@@ -267,7 +265,7 @@ def return_multi_entry(line):
 	# Start of actual MLJohnson code
 	# # # # # # # # # # # # # # # # 
 
-	change_path('texts')
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 
 	definitions = []
 	counter = 0
diff --git a/src/dictionary_Middle_Liddell.py b/src/dictionary_Middle_Liddell.py
index 65b2628..af47fc6 100644
--- a/src/dictionary_Middle_Liddell.py
+++ b/src/dictionary_Middle_Liddell.py
@@ -1,196 +1,17 @@
 
-
-import parser_shell
-from load_dict import change_path
-from copy import deepcopy
-import edit_all
-import pickle
-import beta_code
+from load_dict import change_path, SUPPLEMENTARY_LANGUAGE_FILES
 from language_splitter import split_language
-from dict_utilities import printpr
+from perseus_xml_utilities import printpr, cut_text, translate_greek, smart_join, configure_parts, process_entry, get_def
 
-debug_print = False
 progress_print = True
 
-interval = 1000
-level = 0
-start = (interval * level)
-stop = (interval) * (level + 1)
-
-def cut_text(text,start,stop):
-	p = text.find(start) + len(start)
-	text = text[p:]
-	text = text[:text.find(stop)]
-	return text
-
-def translate_greek(text,bold):
-	text = list(text)
-	text = [x for x in text if not x.isnumeric()]
-	text = "".join(text)
-	if bold:
-		return "<b>" + beta_code.beta_code_to_greek(text) + "</b>"
-	else:
-		return beta_code.beta_code_to_greek(text)
-
-
-def smart_join(text):
-	if debug_print:
-		print(text)
-	s = ""
-	for i in range(len(text)):
-		if i == 0:
-			s = text[i]
-		else:
-			if s[-1] != " " and s[-1] not in ['('] and text[i][0] != " " and text[i][0] not in [',','.',';',')','?']:
-				s += " " + text[i]
-			else:
-				s += text[i]
-	return s.replace(" .",".").replace(" ,",",").replace(" :",":")
-
-def configure_parts(senses):
-	count = 0
-	for i in senses[0]['gloss']:
-		if i == "(":
-			count += 1
-		if i == ")" and count != 0:
-			count -= 1
-		
-		if count < 0:
-			# Unbalance parens
-			if debug_print:
-				# need db printing function for line and function info
-				print(senses[0]['gloss'])
-				print(senses[1]['gloss'])
-			break
-
-	if count != 0:
-		if debug_print:
-			# need db printing function
-			print(senses[0]['gloss'])
-			print(senses[1]['gloss'])
-
-		parens = 0
-		for i in range(len(senses[1]['gloss'])):
-			if senses[1]['gloss'][i] == ")":
-				parens += 1
-			if senses[1]['gloss'][i] == "(":
-				parens -= 1
-			if parens == count:
-				break
-		if i < len(senses[1]['gloss']) - 1:
-			senses[0]['gloss'] = smart_join([senses[0]['gloss'],senses[1]['gloss'][: i + 1]])
-			senses[1]['gloss'] = senses[1]['gloss'][i + 1 :]
-			for i in range(len(senses[1]['gloss'])):
-				if senses[1]['gloss'][i].isalpha() or senses[1]['gloss'][i] == "=":
-					break
-			senses[1]['gloss'] = senses[1]['gloss'][i:]
-		else:
-			senses[0]['gloss'] += ")"
-
-		if debug_print:	
-			# These statements are all useless
-			print(senses[0]['gloss'])
-			print(senses[1]['gloss'])
-	return senses
-
-
-def process_entry(text):
-	definition = {'heading':'',
-				'handle':'',
-				'tags':set("Middle Liddell"),
-				'entries':[]}
-
-	entry = {'senses':[],
-			'partOfSpeech':'',
-			'principleParts':'',
-			'simpleParts':'',
-			'etymology':''}
-
-	handle = cut_text(text,"key=\"","\"")
-	if debug_print:
-		print(handle)
-
-	definition['heading'] = definition['handle'] = translate_greek(handle,False)
-
-	if debug_print:
-		print("@"*5000 + f"\nheading \"{definition['heading']}\"")
-
-	while text != "":
-		text, senses = get_def(text)
-
-		for x in senses:
-			if debug_print:
-				print(f"definition: {x['gloss']}")
-			entry['senses'].append(deepcopy(x))
-		
-	if len(entry['senses']) > 1:
-		entry['senses'] = configure_parts(entry['senses'])
-		entry['simpleParts'] = entry["principleParts"] = entry['senses'][0]['gloss']
-		entry['senses'].pop(0)
-	else:
-		entry['simpleParts'] = entry["principleParts"] = definition['heading']
-	definition['entries'].append(deepcopy(entry))
-	definition['tags'].add("Middle Liddell")
-
-	if debug_print:
-		print(definition)
-	return definition
-
-def get_def(text):
-	m = 0
-	gloss = []
-	senses = []
-	greek = quote = author = False
-	candidate_tag = ''
-	while True:
-		pull = text[:text.find("<")]
-		brac = text[text.find("<"):text.find(">")+1]
-		text = text[text.find(">") + 1:]
-
-		if greek and pull != "":
-			pull = translate_greek(pull,True)
-			greek = False
-
-		if 'lang=\"greek\"' in brac:
-			greek = True
-
-		if "<sense" in brac:
-			gloss = smart_join(gloss).strip(",. ")
-			if gloss != "":
-				senses.append({'gloss':gloss,'tags':[]})
-			gloss = []
-
-		if pull != "":
-			gloss.append(deepcopy(pull))
-
-		if brac == "</sense>" or text == "":
-			gloss = smart_join(gloss).strip(",. ")
-			if gloss != "":
-				senses.append({'gloss':gloss,'tags':[]})
-			break
-
-	return text, senses
-
-def extract_dictionary(perseus, dictionary):
-	line_list = []
-	ignition = False
-	for i in range(len(perseus)):
-
-		if "<entry" in perseus[i]:
-			ignition = True
-		if ignition:
-			line_list.append(perseus[i].strip(" \n\t"))
-		if "</entry" in perseus[i] and ignition:
-			line_list.append(perseus[i].strip())
-			line_list = "".join(line_list)
-			dictionary['definitions'].append(process_entry(line_list))
-			ignition = False
-			line_list = []
-	return dictionary
 
 def middle_liddell(new_dictionary):
+	'''	Function for parsing the Middle Liddell xml file.
+		See readme for more information about the file.
+	'''
 
-	change_path('texts')
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 
 	dictionary = {'file':'','definitions':[],"language":''}
 
@@ -199,33 +20,46 @@ def middle_liddell(new_dictionary):
 			if progress_print:
 				print(f"Parsing 'Perseus_text_1999.04.0058.txt': ",flush=True,end='')
 
+			# line list collects the lines the make up an entry for a single word
+			# in this file words can be spread over multiple lines
 			line_list = []
+
+			# flag indicates when the start of a word may have been found
 			ignition = False
+
+			# used to print progress bar
 			counter = 0
+
+
 			for line in f.readlines():
 
+				# indicates start of a definition
 				if "<entry" in line:
 					ignition = True
+
+				# collect lines until end of definition
 				if ignition:
 					line_list.append(line.strip(" \n\t"))
+
+				# close of entry, join lines and pass to process_entry
 				if "</entry" in line and ignition:
 					line_list.append(line.strip())
 					line_list = "".join(line_list)
-					dictionary['definitions'].append(process_entry(line_list))
+					dictionary['definitions'].append(process_entry(line_list,tag="Middle Liddell"))
 					ignition = False
 					line_list = []
+
 				counter += 1
 				if progress_print:
 					printpr(counter)
-				
 
 			print(f' {counter:,} lines parsed',flush=True)
-
-		new_dictionary['definitions'].extend(dictionary['definitions'])
+		
 	except FileNotFoundError:
 		print("'Perseus_text_1999.04.0058.txt' not found in 'texts' directory")
 		input("Enter to continue")
-	
+
+	new_dictionary['definitions'].extend(dictionary['definitions'])
 	return new_dictionary
 
 
diff --git a/src/edit_all.py b/src/edit_all.py
index c19c4f8..504115f 100644
--- a/src/edit_all.py
+++ b/src/edit_all.py
@@ -12,7 +12,7 @@
 from iteration_utilities import unique_everseen
 from copy import deepcopy
 from unidecode import unidecode
-import load_dict
+from load_dict import change_path, USER_CREATED_DICTIONARIES, FLASHCARD_TEMPLATE_FILES
 import word_print_edit
 import edit_entry
 import edit_dictionary
@@ -64,7 +64,7 @@ def edit_all(current_dict):
 				if i['entries'][0]['partOfSpeech'] == 'verb':
 					i['entries'][0]['simpleParts'] = auto_parts(i['entries'][0]['simpleParts'],True)					
 
-			load_dict.change_path('dictionaries')
+			change_path(USER_CREATED_DICTIONARIES)
 			openFile = open(current_dict['file'],mode = 'wb')
 			pickle.dump(current_dict, openFile)
 			openFile.close()	
@@ -112,7 +112,7 @@ def edit_all(current_dict):
 
 def other_unknown(current_dict):
 	print('re-doing all verbs')
-	load_dict.change_path('templates')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	template_file = "AncientGreek_templates.txt"
 	if template_file not in myFiles:
@@ -138,7 +138,7 @@ def other_unknown(current_dict):
 	user_input = input("Save new verb data (y/n)?")
 	if user_input.lower() == 'y':
 
-		load_dict.change_path('templates')
+		change_path(FLASHCARD_TEMPLATE_FILES)
 		sort_tables(templates,language)
 		with open(template_file,'w') as f:
 			json.dump(templates,f)
@@ -216,7 +216,7 @@ def change_file_name(current_dict):
 	if user_input == '0':
 		return current_dict
 	else:
-		load_dict.change_path('dictionaries')
+		change_path(USER_CREATED_DICTIONARIES)
 		current_dict['file'] = user_input + '.txt'
 		openFile = open(current_dict['file'],mode = 'wb')
 		pickle.dump(current_dict, openFile)
@@ -236,14 +236,14 @@ def replace_senses(current_dict):
 def load_latin(index_letter):
 	if index_letter.lower() not in 'abcdefghijklmnopqrstuvwxyz':
 		index_letter = 'misc'
-	load_dict.change_path("dumps_sorted")
+	change_path("dumps_sorted")
 	with open('Latin-' + index_letter.lower() + '.txt','rb') as openFile:
 		wiki_dump = pickle.load(openFile)
 	return wiki_dump
 
 
 def match_dictionaries(current_dict):
-	load_dict.change_path("dumps_sorted")
+	change_path("dumps_sorted")
 	trie_file = current_dict['language'].replace(" ","") + '-trie.txt'
 
 	print(f"Loading {trie_file}")
@@ -378,7 +378,7 @@ def special(current_dict,start=0):
 def replace_tag(current_dict):
 
 	# Set directory
-	load_dict.change_path('dictionaries')
+	change_path(USER_CREATED_DICTIONARIES)
 
 	while True:
 		tags = word_methods.get_master_list(current_dict)
@@ -423,7 +423,7 @@ def replace_tag(current_dict):
 def convert_to_set(current_dict):
 
 	# Set directory
-	load_dict.change_path('dictionaries')
+	change_path(USER_CREATED_DICTIONARIES)
 
 	# Convert all tags from lists to sets
 	for index in range(len(current_dict['definitions'])):
@@ -441,7 +441,7 @@ def convert_to_set(current_dict):
 def edit_subset(current_dict):
 
 	# Set directory
-	load_dict.change_path('dictionaries')
+	change_path(USER_CREATED_DICTIONARIES)
 	while True:
 
 		# option to set tags
@@ -614,7 +614,7 @@ def cut_parens_access(language):
 		for key in alpha:
 			cut_parens(alpha[key])
 	else:
-		load_dict.change_path("dumps_sorted")
+		change_path("dumps_sorted")
 		with open(language.replace(" ","") + 'Dump.txt','rb') as openFile:
 			wiki_dump = pickle.load(openFile)
 		cut_parens(wiki_dump)
diff --git a/src/edit_dictionary.py b/src/edit_dictionary.py
index 14266f9..64349b7 100644
--- a/src/edit_dictionary.py
+++ b/src/edit_dictionary.py
@@ -21,20 +21,21 @@
 import pickle
 from unidecode import unidecode
 import re
-import random
 
 import word_print_edit
 import parser_shell
 import word_methods
 import get_selection
 import edit_all
-import load_dict
+from load_dict import change_path, USER_CREATED_DICTIONARIES, FORMATTED_FLASHCARD_FILES
 from edit_entry import pretty_print_tags
 
 # EDIT DICTIONARY
 # # # # # # # # # # # # 
 def edit_dictionary(current_dict):
-
+	'''	This is a user menu for editing either inidividual definitions or
+		the entire current user dictionary (using the edit_all module)	
+	'''
 	while True:
 
 		# dictionary options
@@ -75,7 +76,8 @@ def edit_dictionary(current_dict):
 # WORD LOOK UP
 # # # # # # # # # # # # # # # # # # # 
 def word_look_up(current_dict,look_up_word=None):
-
+	'''	Functionality to look-up a word by searching
+	'''
 	while True:
 		# set/reset flag
 		word_found = False
@@ -106,6 +108,8 @@ def word_look_up(current_dict,look_up_word=None):
 # END WORD LOOK UP
 
 def subset_test(tags,word_tags):
+	'''	Utility function to test if tags argument is a subset of word_tags argument
+	'''
 	result = True
 	for i in tags:
 		if i not in word_tags:
@@ -116,8 +120,10 @@ def subset_test(tags,word_tags):
 # WORD LIST
 # # # # # # # # # # # # # # 
 def word_list(current_dict,tags):
-	# whole function contained in loop
-	# flag begins set to false
+	'''	Functionality to selected a definition from a (possibly very long) 
+		number list of the user's current dictionary
+	'''
+
 	invalid_selection = False
 	while True:
 
@@ -183,8 +189,6 @@ def word_list(current_dict,tags):
 		print("Select definition ('0' to go back)")
 		user_input = input(": ")
 
-
-
 		# Option to go back to edit dictionary
 		if user_input == '0':
 			return current_dict
@@ -206,10 +210,12 @@ def word_list(current_dict,tags):
 # EXISTING WORD OPTIONS
 # # # # # # # # # # # # # # # # # # # 
 def existing_word_options(current_dict,word):
-
-
+	'''	Options once a word has been selected are
+		Delete, Edit, re-look-up the word, or split 
+		the word entries between multiple definitions
+	'''
 	# Set directory 
-	load_dict.change_path('dictionaries')
+	change_path(USER_CREATED_DICTIONARIES)
 
 	# whole function contained in loop
 	while True:
@@ -272,13 +278,20 @@ def existing_word_options(current_dict,word):
 			return current_dict
 # END EXISTING WORD OPTIONS
 
-def pos_test_part_latin(definition,pos):
+def pos_test_latin_definitions(definition,pos):
+	'''	Utility function for dividing flashcard sets by partOfSpeech
+		Returns false if no entry has the correct partOfSpeech
+	'''
 	for entry in definition['entries']:
-		if pos_test_part_latin_2(entry['partOfSpeech'],pos):
+		if pos_test_latin_entries(entry['partOfSpeech'],pos):
 			return True
 	return False
 
-def pos_test_part_latin_2(entry_pos,pos):
+def pos_test_latin_entries(entry_pos,pos):
+	'''	Utility function for dividing flashcard sets by partOfSpeech
+		Returns True only if the entry argument has the correct 
+		partOfSpeech
+	'''
 	if pos == 'adjective':
 		if entry_pos == 'adjective' or entry_pos == 'participle':
 			return True
@@ -300,13 +313,20 @@ def pos_test_part_latin_2(entry_pos,pos):
 		else:
 			return True
 
-def pos_test_part_greek(definition,pos):
+def pos_test_greek_definitions(definition,pos):
+	'''	Utility function for dividing flashcard sets by partOfSpeech
+		Returns false if no entry has the correct partOfSpeech
+	'''
 	for entry in definition['entries']:
-		if pos_test_part_greek_2(entry['partOfSpeech'],pos):
+		if pos_test_greek_entries(entry['partOfSpeech'],pos):
 			return True
 	return False
 
-def pos_test_part_greek_2(entry_pos,pos):
+def pos_test_greek_entries(entry_pos,pos):
+	'''	Utility function for dividing flashcard sets by partOfSpeech
+		Returns True only if the entry argument has the correct 
+		partOfSpeech
+	'''
 	if pos == 'verb':
 		if entry_pos == 'verb':
 			return True
@@ -320,39 +340,50 @@ def pos_test_part_greek_2(entry_pos,pos):
 
 
 # PRINT DICT
-# function prints a loaded dictionary as text to a file with ':' separators
 # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
-def print_dict(current_dict,mode='Quizlet'):
+def print_dict(current_dict):
+	'''	Function prints a loaded dictionary as text to a file with special 
+		separator character and html tags for formatting. 
+		Currently focused on supporting Anki flashcard import tool.
+
+		TODO: Add functionality to print a flashcard deck based on user 
+		selected tags. This is already implemented in 'filter_gloss' function
+		that pretty print a page of definitions (See below).
+	'''
 
 	# change file path to 'prints' folder
-	load_dict.change_path('flashcards')
+	change_path(FORMATTED_FLASHCARD_FILES)
 	myFiles = glob.glob('*.txt')
-	if current_dict['language'] == "Latin":
+
+	# option to split flashcard decks by part of speech
+	print("Split flashcard sets by part of part of speech?")
+	user_input = input("Enter 'y' to split, otherwise press enter: ")
+
+	# different setting for Greek and Latin. 
+	# TODO: Allow user to customize these options
+	if current_dict['language'] == "Latin" and user_input.lower() == 'y':
 		split = True
 		pos_list = ['noun','verb','adjective','other']
-		function, function2 = pos_test_part_latin, pos_test_part_latin_2
-	elif current_dict['language'] == "Ancient Greek":
+		pos_test_definitions, pos_test_entries = pos_test_latin_definitions, pos_test_latin_entries
+	elif current_dict['language'] == "Ancient Greek" and user_input.lower() == 'y':
 		split = True
 		pos_list = ['verb','other']
-		function, function2 = pos_test_part_greek, pos_test_part_greek_2
+		pos_test_definitions, pos_test_entries = pos_test_greek_definitions, pos_test_greek_entries
 	else:
 		split = False
 		pos_list = ['other']
+		pos_test_definitions = pos_test_entries = lambda x,y:True
+
 	# Special separator character
 	c = '|'
-	counter = 0
-	limit = 49000
-	files = 1
 
 	while True:
-		tags = []
-		tag_mode = '2'
 
 		# Save a reference to the original standard output
 		original_stdout = sys.stdout 
 
+		# create a different file for each pos in pos_list
 		for pos in pos_list:
-
 			if split:
 				file_name = current_dict['language'].replace(' ','') + "-" + pos.upper() + '-Flashcards.txt'
 			else:
@@ -361,38 +392,42 @@ def print_dict(current_dict,mode='Quizlet'):
 			# assign user selected file to output
 			sys.stdout = open(file_name, 'w')
 
-			dict_range = list(range(len(current_dict['definitions'])))
-			random.shuffle(dict_range)
-
 			# Loop through words in current_dict
-			for i in dict_range:
-				if function(current_dict['definitions'][i],pos) or not split:
-					pass
-				else:
+			for i in range(len(current_dict['definitions'])):
+
+				# if pos test returns False and split == True, skip this entire definition
+				if pos_test_definitions(current_dict['definitions'][i],pos) == False and split == True:
 					continue
 
+				# start new string to by printed as next line in flashcard file
 				word_string = '<P align="left"><!--' + pos + f"-->{current_dict['definitions'][i]['heading'].strip()}</P>{c}"
 
+				# loop through the entries in the definition and print only those matching 'pos'
 				for j in range(len(current_dict['definitions'][i]['entries'])):
 					entry = current_dict['definitions'][i]['entries'][j]
 					partOfSpeech = entry['partOfSpeech']
-					if function2(partOfSpeech,pos) or not split:
-						pass
-					else:
+
+					# if pos test returns False and split == True, skip this particular entry
+					if pos_test_entries(partOfSpeech,pos) == False and split == True:
 						continue
 
-					entry = current_dict['definitions'][i]['entries'][j]
+					# include etymology string is less than 126 characters
 					if 'etymology' in entry:
 						if len(entry['etymology']) <= 125:
-							word_string +=  f'<P align="left">{entry["etymology"]}</P>' 
+							word_string +=  f'<P align="left">{entry["etymology"]}</P>'
+
+					# returns the rest of the entry with proper formatting 
 					word_string += get_entry_string(entry,current_dict['language'])
 
+				# add separator character between end of back of card - beginning of tags
 				word_string += c
 
+				# add tags as a comma separated list in double quotes
 				for tag in current_dict['definitions'][i]['tags']:
 					word_string += '"' + tag + '"; '
 				word_string.strip('; ')
 
+				# print formatted flashcard string to file
 				print(word_string)
 
 
@@ -404,31 +439,38 @@ def print_dict(current_dict,mode='Quizlet'):
 # END PRINT DICT
 
 def split_tags(tags,next_index,previous_tags):
+	'''	This function attempts to group tags together when multiple
+		senses have a set of common tags. If a sense differs from a 
+		group by a single tag the spoiler is inserted into the line
+		for the sense to preserve the grouping.
+	'''
 	current_index = next_index - 1
 
-	''' If previous (current) tags and current tags both exist '''
+	# If previous (current) tags and current tags both exist 
 	if previous_tags != [] and tags[current_index] != []:
 		match = True
+		# previous tags longer than current tags
 		if len(previous_tags) > len(tags[current_index]):
 			match = False
 		else:
+			# check if first n tags match between previous and current tag sets
 			for i in range(len(previous_tags)):
 				if previous_tags[i] != tags[current_index][i]:
 					match = False
-		''' If all previous (common) tags match with first n current tags '''
+		# If all previous (common) tags match with first n current tags 
 		if match:
-			''' Seperate current into common and distinct tags '''
+			# Seperate current into common and distinct tags 
 			return tags[current_index][:i+1], tags[current_index][i+1:]
 
-	''' Current did not match previous common tags, inspect next tags '''
+	# Current did not match previous common tags, inspect next tags 
 	if len(tags) > next_index:
 		if tags[next_index] != []:
-			''' Next tags exist and are not empty '''
+			# Next tags exist and are not empty '''
 			if tags[next_index] == tags[next_index - 1]:
-				''' Tags are exactly the same, all current tags will be common tags '''
+				# Tags are exactly the same, all current tags will be common tags 
 				return tags[current_index], []
 
-			''' Find the smaller of the two lists '''
+			# Find the smaller of the two lists 
 			if len(tags[current_index]) <= len(tags[next_index]):
 				shorter = tags[current_index]
 				longer = tags[next_index]
@@ -437,109 +479,109 @@ def split_tags(tags,next_index,previous_tags):
 				longer = tags[current_index]
 			for i in range(len(shorter)):
 				if shorter[i] != longer[i]:
-					''' Once lists are no longer the same we have common and distict tags '''
+					# Once lists are no longer the same we have common and distict tags 
 					if i == 0:
-						''' If no matches, all tags are common '''
+						# If no matches, all tags are common 
 						return tags[current_index], []
-					''' Else use index to seperate common and distinct '''
+					# Else use index to seperate common and distinct 
 					return tags[current_index][:i], tags[current_index][i:]
 
-	''' If next tags don't exist or are empty, all tags are common tags '''
+	# If next tags don't exist or are empty, all tags are common tags '''
 	return tags[current_index], []
 
 
 def get_entry_string(entry,language):
-	entry_string = ''
-	entry_string += f'<P align="left"><b>' + f"{entry['simpleParts'].strip()}</b><br>"
-	text = [definition['gloss'] for definition in entry['senses']]
-	def_tags = [definition['tags'] for definition in entry['senses']]
+	'''	Functionality to format a definition with html tags so the
+		card with have left alignment, bolded heading and two level ordered lists
+		when diplayed in Anki flashcard manager.
+	'''
+
+	# start with bolded simpleParts for entry heading
+	entry_string = f'<P align="left"><b>' + f"{entry['simpleParts'].strip()}</b><br>"
+
+	# change senses from list of dictionary to two lists
+	sense_glosses = [definition['gloss'] for definition in entry['senses']]
+	sense_tags = [definition['tags'] for definition in entry['senses']]
+
+	# short_senses attempts to trim down overly long senses for more readable flashcards
 	if language == "Latin":
-		text = short_senses(text,def_tags)
-	bank = ["*","^","†","∆"]
-	custom = []
-	while text[0][-1] in bank:
-		custom.append(text[0][-1])
-		text[0] = text[0][:-1]
-	
-	if custom:
-		if len(custom) == 4:
-			entry_string += f'<ol align="left">' #style="color:#750265;">'
-		elif len(custom) >= 2:
-			entry_string += f'<ol align="left">' # style="color:#5C4033;">'
-		elif len(custom) == 1:
-			if custom[0] == f'*':
-				entry_string += f'<ol align="left">' # style="color:#00008B";">'
-			elif custom[0] == '^':
-				entry_string += f'<ol align="left">' # style="color:#006400";">'
-			elif custom[0] == '†':
-				entry_string += f'<ol align="left">' # style="color:#483C32";">'
-			elif custom[0] == '∆':
-				entry_string += f'<ol align="left">' # style="color:#7d022f";">'
-		entry_string += '<!--'
-		if "*" in custom:
-			entry_string += 'Oxford Desk Dictionary, '
-		if "^" in custom:
-			entry_string += 'Lewis and Short, '
-		if "†" in custom:
-			entry_string += 'Wiktionary, '
-		if "∆" in custom:
-			entry_string += 'Learn to Read Latin'
-		entry_string = entry_string.strip(", ") + '-->'
-	else:
-	
-		entry_string += f'<ol align="left">'
-	special_tags = ['LTRG','Oxford','Liddell & Scott','Athenaze']
+		sense_glosses = short_senses(sense_glosses)
 
-	line_tags = def_tags[0]
+	# open first order list
+	entry_string += f'<ol align="left">'
+
+	# start with tags belonging to the first sense
+	line_tags = sense_tags[0]
+	# no previous tags
 	previous_tags = []
-	common_tags, distinct_tags = split_tags(def_tags,1,previous_tags)
+
+	# determines of current sense should continue to be grouped under same
+	# tags as previous and whether current grouping should be closed
+	common_tags, distinct_tags = split_tags(sense_tags,1,previous_tags)
+
+	# determine if a sublist should be started for the first sense
 	open_sublist = False
 	if line_tags:
 		open_sublist = True
 		entry_string += pretty_print_tags(common_tags,-1)
+
+	# next index is an arugment for split_tags
 	next_index = 1
-	for line, tags in zip(text,def_tags):
-		common_tags, distinct_tags = split_tags(def_tags,next_index,previous_tags)
+
+	# iterate through tuples of sense glosses and tags
+	for gloss, tags in zip(sense_glosses,sense_tags):
+
+		# determine if senses are compatible for grouping under common tags
+		common_tags, distinct_tags = split_tags(sense_tags,next_index,previous_tags)
 		previous_tags = common_tags
+
+		# indicates the current grouping must be closed
 		if common_tags != line_tags:
-			tag_break = False
-			for tag in line_tags:
-				if tag in special_tags:
-					tag_break = True
-			for tag in tags:
-				if tag in special_tags:
-					tag_break = False
 			line_tags = common_tags
+
+			# close previous sublist (grouped senses)
 			if open_sublist:
 				entry_string += "</ol></li>"
-			if tag_break:
-				entry_string += '<br>'
+
+			# if next/current sense has tags, start a new sublist
 			if common_tags != []:
 				open_sublist = True
 				entry_string += pretty_print_tags(common_tags,-1)
+			# othter senses will print to list level one
 			else:
 				open_sublist = False
+
+		# 'spoiler' tags are added into the line for the sense
 		if distinct_tags:
-			entry_string += '<li>' + "(" + ",".join(distinct_tags) + ") " + line.strip(";,. ").strip("†∆*^") + '</li>'
+			entry_string += '<li>' + "(" + ",".join(distinct_tags) + ") " + gloss.strip(";,. ").strip("†∆*^") + '</li>'
 		else:
-			entry_string += '<li>' + line.strip(";,. ").strip("†∆*^") + '</li>'
+			entry_string += '<li>' + gloss.strip(";,. ").strip("†∆*^") + '</li>'
+
 		next_index += 1
+
+	# close both list levels, add breaks to give space before next entry starts on multi-entry cards
 	if open_sublist:
 		entry_string += "</ol></li>"
-	entry_string += '</ol></P><br><br>' 
+	entry_string += '</ol></P><br><br>'
+
+	# return formated string to flashcard printing function
 	return entry_string
 
 
 # PRINT GLOSS SETUP
 # # # # # # # # # # # # 
 def print_gloss_setup(current_dict):
-
+	'''	Functionality to pretty print a list of word definitions so that is will fit well
+		into a standard page. The idea to allow the user to create study sheets for a 
+		particular set of tags such a textbook chapter or a section of a Latin text.
+	'''
 
 	# change file path to 'prints' folder
-	load_dict.change_path('glosses')
+	change_path('glosses')
 	myFiles = glob.glob('*.txt')
 
 	while True:
+		# give user option to select from all tags found in the current dictionary
 		master_list = word_methods.get_master_list(current_dict)
 		tags = word_methods.getTags([],'filter',master_list)
 
@@ -661,7 +703,7 @@ def print_gloss(current_dict,tags,partOfSpeech=None,tag_mode='1'):
 					# check if definition exceeds desired length
 					text = [d['gloss'] for d in word['entries'][x]['senses']]
 					dtags = [d['tags'] for d in word['entries'][x]['senses']]
-					#text = short_senses(text, dtags)
+
 					if len(text) == 1: 
 						entry_string += f"~) " + text[0].strip('*^†∆') + ";  "
 					else:
@@ -686,6 +728,8 @@ def print_gloss(current_dict,tags,partOfSpeech=None,tag_mode='1'):
 				elif current_dict['language'] == "Ancient Greek":
 						
 					entry_string = word['entries'][x]['simpleParts'][:word['entries'][x]['simpleParts'].find(')')+1].strip()
+
+					# TODO: this should be replaced with the get_visible_length function from the get_selection module
 					length_string = entry_string.lower().replace("θ",'t')
 					length_string = length_string.replace("χ",'k') 
 					length_string = length_string.replace('φ','f')
@@ -710,92 +754,80 @@ def print_gloss(current_dict,tags,partOfSpeech=None,tag_mode='1'):
 	return counter
 # END PRINT GLOSS
 
+''' The rest of these functions attempt to shorten senses that are overly long
+	to make more useful flashcards.
+'''
+
 # CHOP LINE
 # # # # # # # # # # # # # 
-def chop_line(text,tags):
-	size = sum([len(line) for line in text])
-	if len(text) < 3:
+def chop_line(senses):
+	'''	Determines how much each sense should be shortened based on
+		the total number of senses and the total characters
+	'''
+	size = sum([len(sense) for sense in senses])
+
+	if len(senses) < 3:
 		limit = 5
-	elif len(text) == 3:
+	elif len(senses) == 3:
 		limit = 4
-	elif len(text) > 3:
+	elif len(senses) > 3:
 		limit = 3
 
-	custom = []
-	bank = ["*","^","†","∆"]
-	special_tags = ['LTRG','Oxford','Liddell & Scott','Athenaze']
-	special = False
-	for i in range(len(text)):
-		if text[i] == "":
-			continue
-		for tag in tags[i]:
-				if tag in special_tags:
-					special = True
-		while text[i][-1] in bank:
-			if text[i][-1] not in custom:
-				custom.append(text[i][-1])
-			text[i] = text[i][:-1]
-	if custom:
-		c_string = ''
-		if "*" in custom:
-			c_string += "*"
-		if "^" in custom:
-			c_string += "^"
-		if "†" in custom:
-			c_string += "†"
-		if "∆" in custom:
-			c_string += "∆"
-		text[0] += c_string
-	elif special:
-		pass
-	elif size > 150:
-		for i in range(len(text)):
-			text[i] = short_line(text[i],limit)
-	return text
+	if size > 150:
+		for i in range(len(senses)):
+			senses[i] = short_line(senses[i],limit)
+	return senses
 
 
 # SHORT LINE
 # # # # # # # # # # 
 def short_line(line,limit):
+	'''	Attempts to shorten line, aborts under certain conditions such as
+		parens at the end (usually contain something important)
+	'''
 
-	#print(f"PRINT SHORT LINE WHILE TOP PRE SPLIT:\n{line}")
 	line = re.split(",|;",line)
 	stop = orstop = parstop = limit
+
+	# if line contains and 'or' avoid cutting before the or
 	for i in range(len(line)):
 		orlist = [x for x in line[i:] if " or " in x]
 		if orlist != []:
 			orstop = i + 1
 			continue
 		else:
-			#stop = max(i,limit)
 			break
+	# if line contains parens, avoid cutting before the last closing paren
 	for i in range(len(line)):
 		parlist = [x for x in line[i:] if ")" in x or "(" in x]
 		if parlist != []:
 			parstop = i + 1
 			continue
 		else:
-			#stop = max(i,limit)
 			break
+
+	# determine the least safe cutting point
 	stop = max(orstop,parstop,limit)
 	line = line[:stop]
-	new_text = ''
-	for i in range(len(line)):
-		new_text += line[i].strip() + ', '
-	line = new_text.strip(", ")
-	#print(f"PRINT END SHORT LINE:\n{line}")
+
+	# reconstruct string 
+	new_text = ", ".join(word.strip() for word in line)
+
 	return line
 
 # SHORT senses
 # # # # # # # # # # 
-def short_senses(text,tags):
+def short_senses(text):
+	'''	removes empty strings before and after calling chop_line
+	'''
 	while '' in text:
 		text.remove('')
-	text = chop_line(text,tags)
-	size = sum([len(line) for line in text])
+
+	text = chop_line(text)
 
 	while '' in text:
 		text.remove('')
+
 	for i in range(len(text)):
 		text[i] = text[i].strip(',;')
 	return text
diff --git a/src/edit_entry.py b/src/edit_entry.py
index dc0f2ca..79ad270 100644
--- a/src/edit_entry.py
+++ b/src/edit_entry.py
@@ -23,39 +23,40 @@
 from tables_greek_ext import auto_parts
 from pyfiglet import figlet_format
 
+
+# string used multiple times
+confirm_str = "'1' to confirm, any other key to cancel: "
+
 # EDIT ENRTY
 # # # # # # # # 
 entry_string = ''
 def edit_entry(entry,new_word):
-
-	# string used multiple times
-	confirm_str = "'1' to confirm, any other key to cancel: "
-
-	# rest of function contained in loop
+	''' Menu for user options to edit an entry of a definition.
+		TODO: each option should be moved to a separate function.
+	'''
 	while True:
 		
 		# flag if only one definition exists
-		if len(entry['senses']) == 1:
-			singleton = True
-		else:
-			singleton = False
+		singleton = True if len(entry['senses']) == 1 else False
 
 		# display entry
 		entry_string = get_entry(entry)
 
-		# get user selection
+		# define user options
 		options = {
 		'1':"\n==================================\nEntry Options:\n>'1' to add definition\n",
 		'2':">'2' to change definition\n"}
 		if singleton:
 			options.update({
 				'3':">'3' to replace definition\n"})
-		# only display if more than one definition
+
+		# only display these options if more than one definition
 		if not singleton:
 			options.update({
 				'3':">'3' to replace all\n",
 				'4':">'4' to move definitions\n",
 				'5':">'5' to delete definitions\n"})
+
 		# more options
 		options.update({
 			'tag':">'tag' to tag defintions",
@@ -65,6 +66,7 @@ def edit_entry(entry,new_word):
 			'etym':">'etym' to change etymology\n",
 			'ps':">'ps' to change part of speech\n",
 			'0':">'0' to go back ",'00':">'00' to finish and save\n"})
+
 		user_input = get_selection(options,entry_string)
 
 		# Option to finish/go back
@@ -76,211 +78,48 @@ def edit_entry(entry,new_word):
 
 		# Option to add new
 		elif user_input == '1':
-			while True:
-				print("\nChoose postion of new definition (1-n)")
-				try:
-					place = int(input(": "))-1
-				except:
-					print("Invalid")
-					continue
-				break
-			if place < 0:
-				continue
-			print("\nEnter your new definition ('0' to go back) (ā, ē, ī, ō, ū)")
-			new_definition = {'gloss':input(': ')}
-
-			if new_definition['gloss'] != '0':
-				new_definition['tags'] = []
-				print("Enter definition tags ('0' to finish)")
-				new_tag = input(": ")
-				if new_tag != '0':
-					new_definition['tags'].append(new_tag)
-				entry['senses'].insert(place,new_definition)
+			add_new(entry)
 
+		# apply a new tag to some of the senses within the definition
 		elif user_input.lower() == 'tag':
-			exit_loop = False
-			while not exit_loop:		
-				print("Enter the tag you want to apply ('0' to go back)")
-				new_tag = input(": ")
-				if new_tag == '0':
-					exit_loop = True
-				else:
-					exit_inner_loop = False
-					while exit_inner_loop == False:
-						message = "\n==================================\nChoose the definition you want to tag\n'0' to go back"
-						selection = select_definition(entry,message)
-						if selection == None:
-							exit_inner_loop = True
-						else:
-							entry['senses'][selection]['tags'].append(new_tag)
+			add_new_tag(entry)
 
+		# remove all tags, currently an invisible option
 		elif user_input.lower() == "untag_all":
 			for i in entry['senses']:
 				i['tags'] = []
 
+		# remove a tag from some of the senses within the definition
 		elif user_input.lower() == 'untag':
-			exit_loop = False
-			while not exit_loop:		
-				message = "\n==================================\nChoose the definition you want to untag\n'0' to go back"
-				selection = select_definition(entry,message)
-				if selection == None:
-					exit_loop = True
-				elif entry['senses'][selection]['tags']:
-					exit_inner_loop = False
-					while exit_inner_loop == False:
-						for i in range(len(entry['senses'][selection]['tags'])):
-							print(f"{i+1}. {entry['senses'][selection]['tags'][i]}")
-						print("Select the tag you want to remove ('0' to go back)")
-						tag_no = input(": ")
-						if tag_no == '0':	
-							exit_inner_loop = True
-						elif int(tag_no) - 1 in range(len(entry['senses'][selection]['tags'])):
-							del entry['senses'][selection]['tags'][int(tag_no) - 1]
-							if entry['senses'][selection]['tags'] == []:
-								print("\ndefinitions has no more tags")
-								exit_inner_loop = True
-						else:
-							print("\ninvalid selection")
-				else:
-					print('\ndefinition has no tags')
-
+			remove_tag(entry)
 
 		# Option to change definition
 		elif user_input == '2':
-			exit_loop = False
-			while not exit_loop:
-				if singleton:
-					selection = 0
-				else:
-					message = "\n==================================\nChoose the definition you want to change\n'0' to go back"
-					selection = select_definition(entry,message)
-					if selection == None:
-						exit_loop = True
-				definition_string = ''
-				while selection != None:
-					definition_string += f"Definition: {entry['senses'][selection]['gloss']}\nTags: {', '.join(entry['senses'][selection]['tags'])}\n"
-					options = {'0':f"Change Definition Options:\n>'0' to go back",'00':">'00' to finish\n",'1':">'1' to remove words\n",
-					'2':">'2' to add text to the end\n",
-					'3':">'3' to add text to the beginning\n",
-					'4':">'4' to write new definition\n"}
-					user_input = get_selection(options,definition_string)
-					definition_string = ""
-					if user_input == '0':
-						selection = None
-						if singleton:
-							exit_loop = True
-					elif user_input == '00':
-						selection = None
-						exit_loop == True
-					elif user_input == '1':
-						entry['senses'][selection]['gloss'] = remove_words(entry['senses'][selection]['gloss'])
-					elif user_input == '2':
-						print("\nEnter text to add to definition ('0' to go back) (ā, ē, ī, ō, ū)")
-						new_text = input(': ')
-						if new_text != '0':
-							entry['senses'][selection]['gloss'] += new_text	
-					elif user_input == '3':
-						print("\nEnter text to add to definition ('0' to go back) (ā, ē, ī, ō, ū)")
-						new_text = input(': ')
-						if new_text != '0':
-							entry['senses'][selection]['gloss'] = new_text + entry['senses'][selection]['gloss']		
-					elif user_input == '4':
-						print("\nEnter your new definition ('0' to go back) (ā, ē, ī, ō, ū)")
-						new_definition = input(': ')
-						if new_definition != '0':
-							entry['senses'][selection]['gloss'] = new_definition
-							entry['senses'][selection]['tags'] = []
-							while True:
-								print("Enter definition tags ('0' to finish)")
-								new_tag = input(": ")
-								if new_tag == '0':
-									break
-								else:
-									entry['senses'][selection]['tags'].append(new_tag)
+			change_definition(entry,singleton)
 
 		# Option to move definition
 		elif user_input == '4' and not singleton:
+			move_definition(entry)
 
-			if len(entry['senses']) == 2:
-				entry['senses'] = move_entries(entry['senses'],1,0)
-			else:
-				exit_inner_loop = False
-				while not exit_inner_loop:
-					message = "\n==================================\nChoose the definition you want to move\n'0' to go back"
-					take = select_definition(entry,message)
-
-					if take != None:
-						message = "\nMove to what position?\n'0' to go back"
-						put = select_definition(entry,message)
-
-						if put != None:
-							entry['senses'] = move_entries(entry['senses'],take,put)
-
-					else:
-						exit_inner_loop = True
-
-		# Option to delete definition
+		# Option to delete definition		
 		elif user_input == '5' and not singleton:
-			exit_inner_loop = False
-			while not exit_inner_loop:
-				message = "\n==================================\nChoose the definition you want to delete\n'0' to go back"
-				selection = select_definition(entry,message)
+			delete_definition(entry)
 
-				if selection != None:
-					print(f"\nAre you sure to want to delete {selection+1}?")
-					user_input = input(confirm_str)
-
-					if user_input == '1':
-						del entry['senses'][selection]
-
-				else:
-					exit_inner_loop = True
-				if len(entry['senses']) == 1:
-					exit_inner_loop = singleton = True
-
-		# Options to replace all definitions
+		# Options to replace all definitions		
 		elif user_input == '3':
-			print("\nEnter your new definition ('0' to go back) (ā, ē, ī, ō, ū)")
-			new_definition = {'gloss':input(': ')}
-
-			if new_definition != '0':
-				new_definition['tags'] = []
-
-				print("Enter definition tags ('0' to finish)")
-				new_tag = input(": ")
-				if new_tag != '0':
-					new_definition['tags'].append(new_tag)
-				entry['senses'] = [new_definition]
+			replace_all(entry)
 
-		# Option to rewrite principle parts
+		# Option to rewrite principle parts			
 		elif user_input.lower() == 'parts':
-			print("'1' to auto retreieve verb parts (Greek only), any other key to proceed")
-			user_input = input(": ")
-			if user_input == '1':
-				entry['simpleParts'] = auto_parts(entry['simpleParts'],True)
-			else:
-				print("\nEnter your new principal parts ('0' to go back) (ā, ē, ī, ō, ū)")
-				new_definition = input(': ')
+			change_principle_parts(entry)
 
-				if new_definition != '0':
-					entry['simpleParts'] = new_definition
-
-		# Option to rewrite principle parts
+		# Option to rewrite etymology			
 		elif user_input.lower() == 'etym':
-			print("\nEnter your new etymology ('0' to go back) (ā, ē, ī, ō, ū) ('X' to delete)")
-			user_input = input(': ')
-			if user_input.upper() == "X":
-				entry['etymology'] = ''
-			elif user_input != '0':
-				entry['etymology'] = user_input
+			change_etymology(entry)
 
+		# option to change the partOfSpeech for a definition
 		elif user_input.lower() == 'ps':
-			print("\nEnter your new part of speech ('0' to go back)")
-			user_input = input(': ')
-			if user_input != '0':
-				entry['partOfSpeech'] = user_input
-
-
+			change_pos(entry)
 
 # END EDIT ENTRY
 
@@ -288,40 +127,70 @@ def edit_entry(entry,new_word):
 # REMOVE WORDS
 # # # # # # # # # # # 
 def remove_words(text):
+	'''	This function allows the user to delete a substring from a definition
+		by specifying the start and end point to 'snip'. The function displays
+		the definition on a grid showing the user how to specify the start and 
+		end point. 
+		The word is divided into rows of 26 characters where each character in
+		the row is under a column heading with the 26 letters of the alphabet.
+	'''
 	text = list(text)		
-	#print(f'text = {text}')
 	invalid = False
 	while True:
 		clear_screen()
+
+		# compute number of rows 
 		rows = 1+len(text)//26
-		#print(f"Rows  == {1+len(text)//26}")
+
+		# print top of box that surrounds grid
 		print('*' * 35 + " |")
+
 		for i in range(rows):
+
+			# print letters for row indices
 			print(f"Row ({chr(i + 65)}): ",end='')
-			#print(f"len(text[ 26 * i : 26 * (i + 1) ]) == {len(text[ 26 * i : 26 * (i + 1) ])}")
-			#print(f"text[ 26 * i : 26 * (i + 1) ] == {text[ 26 * i : 26 * (i + 1) ]}")
+
+			# print letters for columns indices
 			for j in range(len(text[ 26 * i : 26 * (i + 1) ])):
 				print(chr(j+65),end='')
+
+			# print '|'s to box in grid
 			pad = 26 - len(text[ 26 * i : 26 * (i + 1) ]) 
 			print(' ' * pad + " |")
 			print(' ' * 9,end='')
+
+			# print portion of sense that belong in this row
 			for j in range(26 * i,(26 * i) + len(text[ 26 * i : 26 * (i + 1) ])):
-				#print(f"range(26 * i,len(text[ 26 * i : 26 * (i + 1) ]) == {range(26 * i,len(text[ 26 * i : 26 * (i + 1) ]))}")
 				print(text[j],end='')
+
+			# print '-'s and '|'s to box in grid
 			pad = 26 - len(text[ 26 * i : 26 * (i + 1) ]) 
 			print(' ' * pad + " |")		
 			print('-' * 35 + " |")
+
+		# print '*'s and '|' to complete box
 		print('*' * 35 + " |")
+
+		# print message with UI instructions
 		print("To cut enter 'Start Row, Start Col, Stop Row, Stop Col':'RC,RC' ('0' to stop): ")
+
+		# if previous entry was invalid
 		if invalid:
 			print("\nInvalid entry\n\n")
 			invalid = False
+
 		user_input = input(": ")
+
+		# choice to exit
 		if user_input == '0':
+
+			# construct return string
 			return_text = ''
 			for i in range(len(text)):
 				return_text += text[i]
 			return return_text
+
+		# try to decode user input and cut substring
 		else:
 			try:
 				user_input = user_input.split(',')
@@ -334,12 +203,241 @@ def remove_words(text):
 				text = text[:start] + text[stop:]
 			except:
 				invalid = True
-# # # # # # # # # # # # # # # 
+# END remove_words
+
 
+def add_new(entry):
+	''' Add a new sense to the entry
+	'''
+	while True:
+		print("\nChoose postion of new definition (1-n)")
+		try:
+			place = int(input(": "))-1
+		except:
+			print("Invalid")
+			continue
+		break
+	if place < 0:
+		return
+	print("\nEnter your new definition ('0' to go back) (ā, ē, ī, ō, ū)")
+	new_definition = {'gloss':input(': ')}
+
+	if new_definition['gloss'] != '0':
+		new_definition['tags'] = []
+		print("Enter definition tags ('0' to finish)")
+		new_tag = input(": ")
+		if new_tag != '0':
+			new_definition['tags'].append(new_tag)
+		entry['senses'].insert(place,new_definition)
+
+def add_new_tag(entry):
+	''' Add a new tag, apply tag to multiple senses until finished
+	'''
+	exit_loop = False
+	while not exit_loop:		
+		print("Enter the tag you want to apply ('0' to go back)")
+		new_tag = input(": ")
+		if new_tag == '0':
+			exit_loop = True
+		else:
+			exit_inner_loop = False
+			while exit_inner_loop == False:
+				message = "\n==================================\nChoose the definition you want to tag\n'0' to go back"
+				selection = select_definition(entry,message)
+				if selection == None:
+					exit_inner_loop = True
+				else:
+					entry['senses'][selection]['tags'].append(new_tag)
+
+def remove_tag(entry):
+	'''	User selects a sense and tags to remove
+	'''
+	exit_loop = False
+	while not exit_loop:		
+		message = "\n==================================\nChoose the definition you want to untag\n'0' to go back"
+		selection = select_definition(entry,message)
+		if selection == None:
+			exit_loop = True
+		elif entry['senses'][selection]['tags']:
+			exit_inner_loop = False
+			while exit_inner_loop == False:
+				for i in range(len(entry['senses'][selection]['tags'])):
+					print(f"{i+1}. {entry['senses'][selection]['tags'][i]}")
+				print("Select the tag you want to remove ('0' to go back)")
+				tag_no = input(": ")
+				if tag_no == '0':	
+					exit_inner_loop = True
+				elif int(tag_no) - 1 in range(len(entry['senses'][selection]['tags'])):
+					del entry['senses'][selection]['tags'][int(tag_no) - 1]
+					if entry['senses'][selection]['tags'] == []:
+						print("\ndefinitions has no more tags")
+						exit_inner_loop = True
+				else:
+					print("\ninvalid selection")
+		else:
+			print('\ndefinition has no tags')
+
+def change_definition(entry,singleton):
+	''' User is given the option to remove text from any part of the sense
+		or add text to the beginning or ending of the sense. 
+	'''
+	while True:
+
+		# get user selection for sense to modify
+		if singleton:
+			selection = 0
+		else:
+			message = "\n==================================\nChoose the definition you want to change\n'0' to go back"
+			selection = select_definition(entry,message)
+			if selection == None:
+				return
+
+		
+		while selection != None:
+
+			# display gloss, tags and user options
+			definition_string = f"Definition: {entry['senses'][selection]['gloss']}\nTags: {', '.join(entry['senses'][selection]['tags'])}\n"
+			options = {'0':f"Change Definition Options:\n>'0' to go back",'00':">'00' to finish\n",'1':">'1' to remove words\n",
+			'2':">'2' to add text to the end\n",
+			'3':">'3' to add text to the beginning\n",
+			'4':">'4' to write new definition\n"}
+			user_input = get_selection(options,definition_string)
+
+			# option to go back (exit if singleton)
+			if user_input == '0':
+				selection = None
+				if singleton:
+					return
+			# option to exit back to edit entry menu
+			elif user_input == '00':
+				return
+
+			# option to remove text from any part of sense
+			elif user_input == '1':
+				entry['senses'][selection]['gloss'] = remove_words(entry['senses'][selection]['gloss'])
+
+			# option to add to end of sense
+			elif user_input == '2':
+				print("\nEnter text to add to definition ('0' to go back) (ā, ē, ī, ō, ū)")
+				new_text = input(': ')
+				if new_text != '0':
+					entry['senses'][selection]['gloss'] += new_text	
+
+			# option to add to beginning of sense
+			elif user_input == '3':
+				print("\nEnter text to add to definition ('0' to go back) (ā, ē, ī, ō, ū)")
+				new_text = input(': ')
+				if new_text != '0':
+					entry['senses'][selection]['gloss'] = new_text + entry['senses'][selection]['gloss']
+
+			# option to overwrite definition		
+			elif user_input == '4':
+				print("\nEnter your new definition ('0' to go back) (ā, ē, ī, ō, ū)")
+				new_definition = input(': ')
+				if new_definition != '0':
+					entry['senses'][selection]['gloss'] = new_definition
+					entry['senses'][selection]['tags'] = []
+					while True:
+						print("Enter definition tags ('0' to finish)")
+						new_tag = input(": ")
+						if new_tag == '0':
+							break
+						else:
+							entry['senses'][selection]['tags'].append(new_tag)
+
+def change_principle_parts(entry):
+	'''	principle parts set to requested user input
+	'''
+	print("'1' to auto retreieve verb parts (Greek only), any other key to proceed")
+	user_input = input(": ")
+	if user_input == '1':
+		entry['simpleParts'] = auto_parts(entry['simpleParts'],True)
+	else:
+		print("\nEnter your new principal parts ('0' to go back) (ā, ē, ī, ō, ū)")
+		new_definition = input(': ')
+
+		if new_definition != '0':
+			entry['simpleParts'] = new_definition
+
+def change_etymology(entry):
+	'''	etymology set to requested user input
+	'''
+	print("\nEnter your new etymology ('0' to go back) (ā, ē, ī, ō, ū) ('X' to delete)")
+	user_input = input(': ')
+	if user_input.upper() == "X":
+		entry['etymology'] = ''
+	elif user_input != '0':
+		entry['etymology'] = user_input
+
+def change_pos(entry):
+	'''	pos set to requested user input
+	'''
+	print("\nEnter your new part of speech ('0' to go back)")
+	user_input = input(': ')
+	if user_input != '0':
+		entry['partOfSpeech'] = user_input
+
+def move_definition(entry):
+	'''	validate user input for move entries function
+	'''
+	if len(entry['senses']) == 2:
+		entry['senses'] = move_entries(entry['senses'],1,0)
+	else:
+		exit_inner_loop = False
+		while not exit_inner_loop:
+			message = "\n==================================\nChoose the definition you want to move\n'0' to go back"
+			take = select_definition(entry,message)
+
+			if take != None:
+				message = "\nMove to what position?\n'0' to go back"
+				put = select_definition(entry,message)
+
+				if put != None:
+					entry['senses'] = move_entries(entry['senses'],take,put)
+
+			else:
+				exit_inner_loop = True
+
+def delete_definition(entry):
+	'''	validate user input to delete a sense
+	'''
+	exit_inner_loop = False
+	while not exit_inner_loop:
+		message = "\n==================================\nChoose the definition you want to delete\n'0' to go back"
+		selection = select_definition(entry,message)
+
+		if selection != None:
+			print(f"\nAre you sure to want to delete {selection+1}?")
+			user_input = input(confirm_str)
+
+			if user_input == '1':
+				del entry['senses'][selection]
+
+		else:
+			exit_inner_loop = True
+		if len(entry['senses']) == 1:
+			exit_inner_loop = singleton = True	
+
+def replace_all(entry):
+	'''	senses replaced with a single sense from user input
+	'''
+	print("\nEnter your new definition ('0' to go back) (ā, ē, ī, ō, ū)")
+	new_definition = {'gloss':input(': ')}
+
+	if new_definition != '0':
+		new_definition['tags'] = []
+
+		print("Enter definition tags ('0' to finish)")
+		new_tag = input(": ")
+		if new_tag != '0':
+			new_definition['tags'].append(new_tag)
+		entry['senses'] = [new_definition]	
 
 # MOVE ENTRIES
 # # # # # # # # # # # # # # # # # 
 def move_entries(entries,selection,new_position):
+	''' Rearrange object in list from selection to new_position
+	'''
 	if selection == new_position:
 		return
 	else:
@@ -353,10 +451,12 @@ def move_entries(entries,selection,new_position):
 # END MOVE ENTRIES
 
 def pretty_print_tags(tags,mode=[]):
-	
+	''' Utility function for printing senses in two level list
+		based on tag groupings
+	'''
+
 	''' -1 is mode for html printing '''
 	''' else mode corresponds to counter '''
-
 	if mode != -1:
 		string = f'{mode}. ('
 	else:
@@ -376,6 +476,12 @@ def pretty_print_tags(tags,mode=[]):
 
 
 def split_tags(senses,next_index,previous_tags):
+	''' This function tries to group a common tags between senses
+		so that the entry displays more cleanly. If most of the
+		tags match, the senses will be grouped in a sublist.
+		Any individual tags the would break up a logical grouping
+		may be added to the individual lines.
+	'''
 	current_index = next_index - 1
 
 	''' If previous (current) tags and current tags both exist '''
@@ -419,27 +525,13 @@ def split_tags(senses,next_index,previous_tags):
 	''' If next tags don't exist or are empty, all tags are common tags '''
 	return senses[current_index]['tags'], []
 
-'''
-
-1A. If first n tags match with next list
-
-	Common tags become common_tags, distinct tags become distinct tags
 
-1B. If no tags match OR next list does not exist
 
-	All tags become common_tags, no tags become distict tags
-
-2A. If previous common_tags matches with first n tags of current tags
-
-	identify distinct tags as distinct_tags
-
-2B. If common_tags does not match first n tags of current tags
-
-	Go back to Step 1
-
-
-'''
 def convert_message(message,string):
+	''' this function joins a new string to the message being built
+		by the get_entry function. Keeps the strings to < 129 
+		characters before separating into a new line.
+	'''
 	modulus = 129
 	if len(message) < modulus:
 		string += message + "\n"
@@ -458,6 +550,14 @@ def convert_message(message,string):
 	return string
 
 def get_entry(entry,mode='',trunc=False):
+	'''	Get a formatted string representing an entire word entry.
+		Prints the entry etymology, partOfSpeech and simpleParts,
+		followed by the senses for the entry.
+		The sense are printed in two list levels.
+		Level 1: arabic numerals, any untagged senses or a list of tags.
+		Level 2: lower-case roman numerals, one or more sense under a
+		common set of tags
+	'''
 	string = ''
 	iv = ['i', 'ii', 'iii', 'iv', 'v', 'vi', 'vii', 'viii', 'ix', 'x', 'xi', 'xii', 'xiii', 'xiv', 'xv', 'xvi', 'xvii', 'xviii', 'xix', 'xx', 'xxi', 'xxii', 'xxiii', 'xxiv', 'xxv', 'xxvi', 'xxvii', 'xxviii', 'xxix', 'xxx', 'xxxi', 'xxxii', 'xxxiii', 'xxxiv', 'xxxv', 'xxxvi', 'xxxvii', 'xxxviii', 'xxxix', 'xl', 'xli', 'xlii', 'xliii', 'xliv', 'xlv', 'xlvi', 'xlvii', 'xlviii', 'xlix', 'l']
 
@@ -539,7 +639,9 @@ def print_entry(entry,mode=''):
 # SELECT DEFINITIONS
 # # # # # # # # # # # # # # 
 def select_definition(entry,message):
-	# whole function contained in loop
+	''' user input function for a selecting a definition
+		for modification, deletion, etc.
+	'''
 	invalid = False
 	while True:
 		clear_screen()
@@ -555,8 +657,6 @@ def select_definition(entry,message):
 		# Option to go back
 		if user_input == '0':
 			return None
-		#elif user_input == '00':
-		#	return None, True
 
 		# confirm input is numeric
 		elif "-" in user_input:
diff --git a/src/flashcard_html_utilities.py b/src/flashcard_html_utilities.py
index afaab66..bb053a3 100644
--- a/src/flashcard_html_utilities.py
+++ b/src/flashcard_html_utilities.py
@@ -1,3 +1,8 @@
+'''
+Fuctions used by tables.py to print flashcards with tables containing
+verb conjugations and noun/adjective cases
+'''
+
 
 def set_styles(body_string):
 	body_string += '<style type="text/css">\
diff --git a/src/get_selection.py b/src/get_selection.py
index e95f712..9919af5 100644
--- a/src/get_selection.py
+++ b/src/get_selection.py
@@ -9,20 +9,31 @@
 import unicodedata
 import os
 
-# CLEAR SCREEN
+
 def clear_screen():
+	# CLEAR SCREEN
 	if os.name == 'posix':  # For UNIX or Linux or MacOS
 		os.system('clear')
 	elif os.name == 'nt':  # For Windows
 		os.system('cls')
 
 def visible_len(s):
-    return len([c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn'])
+	''' Returns the visible length of unicode characters for correct columns justification 
+	'''
+	return len([c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn'])
+
+
+def fancy(message):
+	# return message with an underline of '='s for menus
+	return message + '\n' + '=' * min(len(message),30)
 
 def get_selection(options, message=""):
+	'''	Take a dictionary of <options (1, 2, a, b, etc.)>:<options descriptions>
+		Validates user input and returns choice
+	'''
 	invalid = False
 	while True:
-		clear_screen()  # Uncomment this if you have a clear_screen function
+		clear_screen() 
 		if message:
 			print(message)
 
@@ -44,7 +55,10 @@ def get_selection(options, message=""):
 		else:
 			invalid = True
 
+
 def print_columns(options,field=25):
+	'''	print many options in columns
+	'''
 	limit = 40
 	keys = list(options.keys())
 	special_keys = ['0', '00']
@@ -78,82 +92,7 @@ def print_columns(options,field=25):
 		if key in options:
 			print(options[key], end='')
 
-
-'''
-# GET SELECTION
-# # # # # # # # # # # # # # 
-def get_selection(options,message=""):
-	# whole function contained in loop
-	invalid = False
-	while True:
-		clear_screen()
-		if message:
-			print(message)
-
-		if len(list(options.keys())) > 30:
-			print_columns(options)
-		else:
-			for key in options:
-				print(f"{options[key]}",end='')
-		if invalid:
-			print("\ninvalid selection\n\n")
-			invalid = False
-		user_input = unidecode(input(": "))
-
-		# check if input matches and keys in options
-		if user_input.lower() in options:
-			return user_input
-		else:
-			invalid = True
-			
-
-# END GET SELECTION
-
-def print_columns(options):
-	limit = 50
-	keys = list(options.keys())
-	if '0' in keys:
-		end = ['0']
-		keys.remove('0')
-	if '00' in keys:
-		end.append('00')
-		keys.remove('00')
-	L = len(keys)
-	if L > 1000:
-		print_bigger_columns()
-	else:
-		step = L // limit + 1
-		for i in range(0,limit):
-			for x in range(step):
-				q = i + limit * x
-				if q >= L:
-					continue
-				else:
-					fill_char = ' '
-					# using .format()
-					print_str = "{message:{fill}<30}".format(message=options[keys[q]], fill=fill_char)
-					def multi_replace(string):
-						replacements = [ ('θ','t'), ('ψ','s'), ('φ','f'), ('̓',''), ]
-						for old, new in replacements:
-							string = string.replace(old, new)
-						return string
-					len_str = multi_replace(print_str)
-					while len(len_str) < 25:
-						len_str += "#"
-						print_str += "#"
-					while len(print_str) > 25:
-						len_str = len_str[:-1]
-						print_str = print_str[:-1]
-					print(print_str, end='')
-					
-			print()
-		for key in end:
-			print(options[key],end="")
-			
-'''	
-
-
-
-
 def print_bigger_columns(options):
+	'''	hope to add paging functionality when columns don't fit in window
+	'''
 	pass
\ No newline at end of file
diff --git a/src/get_simple.py b/src/get_simple.py
index 47eae37..3fc23a0 100644
--- a/src/get_simple.py
+++ b/src/get_simple.py
@@ -12,32 +12,32 @@
 '''
 
 from unidecode import unidecode
-import load_dict
+from load_dict import change_path, KAIKKI_JSON_FILES, SUPPLEMENTARY_LANGUAGE_FILES
 import pickle
 
 
-def load_dump():
+def load_sorted_language():
 	try:
 		print("Loading previous Latin trie...")
-		load_dict.change_path("dumps_sorted")
+		change_path(KAIKKI_JSON_FILES)
 		with open("Latin" + '-trie.txt','rb') as openFile:
 			t = pickle.load(openFile)
 		return t['definitions']
 	except FileNotFoundError:
-		print("'Latin-trie.txt' not found in 'dumps_sorted' directory")
+		print(f"'Latin-trie.txt' not found in {KAIKKI_JSON_FILES} directory")
 		return None
 
 
 def load_i_stem_trie():
-	load_dict.change_path("dumps_sorted")
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 	try:
 		with open("Latin-i_stem_nouns-trie.txt",'rb') as openFile:
 			t = pickle.load(openFile)
 		return t['definitions']
 	except FileNotFoundError:
-		print("'Latin-i_stem_nouns-trie.txt' not found in 'dumps_sorted' directory")
+		print(f"'Latin-i_stem_nouns-trie.txt' not found in {SUPPLEMENTARY_LANGUAGE_FILES} directory")
 		input("Enter to continue")
-		return load_dump()
+		return load_sorted_language()
 
 quickmode = True
 i_stem_mode = False
@@ -45,7 +45,7 @@ def load_i_stem_trie():
 if quickmode:
 	t = load_i_stem_trie()
 else:
-	t = load_dump()
+	t = load_sorted_language()
 
 # CHOP PARTS
 # # # # # # # # # # 
diff --git a/src/language_splitter.py b/src/language_splitter.py
index 6c3e933..f490e6a 100644
--- a/src/language_splitter.py
+++ b/src/language_splitter.py
@@ -1,37 +1,49 @@
 
 
-from load_dict import change_path
+from load_dict import change_path, SORTED_LANGUAGE_FILES
 from unidecode import unidecode
 import pickle
 import datrie
 
 def split_language(new_dictionary):
+	'''	Take a list of definitions and converts it to a datrie.
+		If multiple distinct definitions belong to the same node
+		in the trie due to unidecoding to the same string, the 
+		node will containt a list of definitions.
+	'''
 
+	# initialize trie
 	alpha = 'abcdefghijklmnopqrstuvwxyz-'
-
 	t = datrie.Trie(alpha)
-	#counter = 0
+
 	for i in range(len(new_dictionary['definitions'])):
-		if any(entry['simpleParts'] != False for entry in new_dictionary['definitions'][i]['entries']):
-			#counter += 1
-			try:
-				key = unidecode(new_dictionary['definitions'][i]['heading']).lower()
-				if key not in t:
-					t[key] = new_dictionary['definitions'][i]
+		try:
+			# key is the unidecode string of the entry heading
+			key = unidecode(new_dictionary['definitions'][i]['heading']).lower()
+
+			# if key is free to use
+			if key not in t:
+				t[key] = new_dictionary['definitions'][i]
+
+			# if key is already used
+			else:
+				# if a list is already started
+				if isinstance(t[key],list):
+					t[key].append(new_dictionary['definitions'][i])
+
+				# otherwise start a list with [previous item, new item]
 				else:
-					if isinstance(t[key],list):
-						t[key].append(new_dictionary['definitions'][i])
-					else:
-						t[key] = [t[key],new_dictionary['definitions'][i]]
-
-			except KeyError:
-				print(f"{new_dictionary['definitions'][i]} could not be added")
-	#print(counter)
-	#if counter == 0:
-	#	return
+					t[key] = [t[key],new_dictionary['definitions'][i]]
+
+		except KeyError:
+			print(f"{new_dictionary['definitions'][i]} could not be added")
+
+	# rename new_dictionary file and replace list with trie
 	new_dictionary['file'] = new_dictionary['language'].replace(' ','') + "-trie.txt"
 	new_dictionary['definitions'] = t
-	change_path("dumps_sorted")
+
+	# save to sorted files directory
+	change_path(SORTED_LANGUAGE_FILES)
 	with open(new_dictionary['file'],mode = 'wb') as openFile:
 		pickle.dump(new_dictionary, openFile,protocol=pickle.HIGHEST_PROTOCOL)
 
diff --git a/src/load_dict.py b/src/load_dict.py
index 0c196bb..8f29655 100644
--- a/src/load_dict.py
+++ b/src/load_dict.py
@@ -25,6 +25,14 @@
 # save the parent directory of the current file into a global variable
 PARENT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
+# define names for important directories
+KAIKKI_JSON_FILES = 'kaikki_json_files'
+SORTED_LANGUAGE_FILES = 'sorted_language_files'
+SUPPLEMENTARY_LANGUAGE_FILES = 'supplementary_language_files'
+USER_CREATED_DICTIONARIES = 'user_created_dictionaries'
+FLASHCARD_TEMPLATE_FILES = 'flash_card_templates'
+FORMATTED_FLASHCARD_FILES = 'formatted_flashcard_files'
+
 # CHANGE PATH
 # # # # # # # # # 
 def change_path(folder=''):
@@ -34,12 +42,10 @@ def change_path(folder=''):
 	os.chdir(path)
 # END CHANGE PATH
 
-
-
 # FIND DICT
 # # # # # # # 
 def find_dict():
-	change_path('dictionaries')
+	change_path(USER_CREATED_DICTIONARIES)
 	myFiles = glob.glob('*.txt')
 	if myFiles == []:
 		print("\nSorry no saved dictionaries")
@@ -57,11 +63,10 @@ def find_dict():
 	return current_dict
 # END FIND DICT
 
-
 # CREATE DICT
 # # # # # # # # 
 def create_dict():
-	change_path('dictionaries')
+	change_path(USER_CREATED_DICTIONARIES)
 	myFiles = glob.glob('*.txt')
 	while True:
 		print("What do you want to name new dictionary?: (0 to go back)\n==================================\n")
@@ -94,15 +99,11 @@ def create_dict():
 					exit_loop = True
 # END CREATE DICT
 
-
-
-
-
 # COMBINE DICT
 # # # # # # # # # # # # 
 def combine_dict(current_dict,combo_dict=[]):
 	if combo_dict == []:
-		change_path('dictionaries')
+		change_path(USER_CREATED_DICTIONARIES)
 		myFiles = glob.glob('*.txt')
 		if current_dict['file'] in myFiles:
 			myFiles.remove(current_dict['file'])
@@ -156,111 +157,3 @@ def pick_language():
 		return None
 	else:
 		return language_options[int(user_input)-1]
-
-# EXTRACT LIST
-# # # # # # # # # # # # # # # 
-def extract_list(current_dict,mode=0):
-
-	change_path('lists')
-	myFiles = glob.glob('*.txt')
-	if myFiles == []:
-		print("\nSorry no saved lists")
-		return 
-	else:
-		options = {'0':f"\nChoose from the following files: (0 to go back)\n"}
-		for index in range(len(myFiles)):
-			options[f"{str(index + 1)}"] = f"{index + 1}. {myFiles[index]}\n"
-		user_input = get_selection(options)
-		if user_input == '0':
-			return 
-		else:
-			with open(myFiles[int(user_input)-1],'r') as file:
-				word_list = [unidecode(line).strip("\n\t, ") for line in file.readlines()]
-
-		new_dictionary = {'definitions':[],'file':'','language':'Latin'}
-	while True:
-		if mode == 1:
-			file_name = input("Enter name of new dictionary ('0' to go back): ")
-			if file_name == '0':
-				return
-			else:
-				user_input = pick_language()
-				if user_input == None:
-					continue
-				else:
-					new_dictionary['language'] = user_input
-					new_dictionary['file'] = file_name + ".txt"
-		else:
-			new_dictionary['language'] = current_dict['language']
-			new_dictionary['file'] =  myFiles[int(user_input)-1]
-
-		#new_dictionary['file'] = file_name + ".txt"
-		tag = ''
-		user_input = input("Enter a tag to apply to dictionary entries (max=1,'0' to skip): ")
-		if user_input != '0':
-			tag = user_input
-
-
-
-		if new_dictionary['language'] != 'Latin':
-			#dump_dict = parser_shell.load_dump(new_dictionary['language'])
-			for word in word_list:
-				for i in range(len(dump_dict['definitions'])):
-					if dump_dict['definitions'][i]['handle'] == word:
-						dump_dict['definitions'][i]['tags'].append(tag)
-						new_dictionary['definitions'].append(copy.deepcopy(dump_dict['definitions'][i]))
-		else:
-			alpha = {'a':[],
-			'b':[],
-			'c':[],
-			'd':[],
-			'e':[],
-			'f':[],
-			'g':[],
-			'h':[],
-			'i':[],
-			'j':[],
-			'k':[],
-			'l':[],
-			'm':[],
-			'n':[],
-			'o':[],
-			'p':[],
-			'q':[],
-			'r':[],
-			's':[],
-			't':[],
-			'u':[],
-			'v':[],
-			'w':[],
-			'x':[],
-			'y':[],
-			'z':[],
-			'misc':[]}
-			for key in alpha:
-				alpha[key] = parser_shell.load_big_language(key,current_dict['language']) 
-			
-			for word in word_list:
-				if word[0].lower() not in 'abcdefghijklmnopqrstuvwxyz':
-					key = 'misc'
-				else:
-					key = word[0].lower()
-				for i in range(len(alpha[key]['definitions'])):
-					if unidecode(alpha[key]['definitions'][i]['handle']) == unidecode(word):
-						alpha[key]['definitions'][i]['tags'].append(tag)
-						new_dictionary['definitions'].append(copy.deepcopy(alpha[key]['definitions'][i]))
-		if mode == 1:
-			change_path('dictionaries')
-			with open(new_dictionary['file'],mode = 'wb') as openFile:
-				pickle.dump(new_dictionary, openFile)
-			print(f"{new_dictionary['file']} successfully saved")
-		else:
-			combine_dict(current_dict,new_dictionary)
-		return
-
-
-
-
-
-
-
diff --git a/src/main.py b/src/main.py
index 67ca4d7..b051b4b 100644
--- a/src/main.py
+++ b/src/main.py
@@ -3,7 +3,7 @@
 import word_methods
 import edit_dictionary
 from get_selection import get_selection, clear_screen
-import dump_parser
+import convert_file_utilities
 import os
 import tables
 from pyfiglet import figlet_format
@@ -59,7 +59,7 @@
 	elif user_input == '2':
 		current_dict = create_dict()
 	elif user_input == '3':
-		dump_parser.sort_dump()
+		convert_file_utilities.convert_files()
 
 	# find/create will return {} if dict not loaded
 	# must have a valid dictionary to proceed to new loop
diff --git a/src/parser_shell.py b/src/parser_shell.py
index 7ca744c..783e9c2 100644
--- a/src/parser_shell.py
+++ b/src/parser_shell.py
@@ -1,22 +1,26 @@
-
+'''
+This is the main module for interacting with sorted language dictionaries.
+Allows user to look up words, edit and add them to user dictionaries.
+'''
 
 import pickle
 import os
 from unidecode import unidecode
 from copy import deepcopy
+import unicodedata
+import inspect
+from pyfiglet import figlet_format
 
 from create_word import create_word
 import word_methods
 from word_print_edit import get_entry_string, edit_entries, word_combo
 from get_selection import get_selection, clear_screen
 import edit_dictionary
-import load_dict
+from load_dict import change_path, SORTED_LANGUAGE_FILES, USER_CREATED_DICTIONARIES
 import tables
-import unicodedata
-import inspect
-from pyfiglet import figlet_format
 
-theme = '\u2624'
+
+# character used to put box around search display
 theme = "|"
 
 def current_line_number():
@@ -25,88 +29,138 @@ def current_line_number():
 # ADD WORDS OPTIONS
 # # # # # # # # # # #
 def add_word_options(current_dict):
+	'''	user options for interacting with sorted language file and
+		adding words to customized user dictionary.
+	'''
+	# TODO: definition tags is a set() in some places and a list in others
 	tags = set()
-	while(True):
+
+	while True:
 		clear_screen()
+
+		# create user options
 		options = {'1':"\nWord Search Options:\n==================================\n>'1' word search\n",
 			'2':">'2' to set tags\n",
 			'3':">'3' to display current gloss\n",
 			'4':">'4' to create word\n",
 			't':">'T' for tables\n",
 			'0':">'0' to exit ('00' to quit)\n"}
+
+		# indicate current tags or none; these will be added to each word
+		# that is saved (including updates of previously saved words)
+		# Avoids user having to remember to tag each word. The assumption
+		# is that the user will want to apply some common tags to all words
+		# in a given session.
 		if not tags:
 			options['0'] += "** No tags selected **\n"
 		else:
 			options['0'] += f"* {', '.join(tags)} *\n"
+
+		# ensure user makes a valid selection
 		user_input = get_selection(options)
+
+		# options to exit or quit program completely
 		if user_input == '0':
 			return current_dict, False
 		if user_input == '00':
 			return current_dict, True
+
+		# option to interact with sorted language file
 		if user_input == '1':
 			current_dict = word_search(current_dict,tags)
 			continue
+
+		# option to set session tags
 		elif user_input.lower() == '2':
 			master_list = word_methods.get_master_list(current_dict)
 			tags = word_methods.getTags(tags,'',master_list)
 			continue
+
+		# option to pretty print all words in current dictionary that match
+		# current session tags.
 		elif user_input.lower() == '3':
 			tag_mode = '1' if tags == set() else '2'
 			count = edit_dictionary.filter_gloss(current_dict,tags,output_file=None,tag_mode=tag_mode)
 			print(f"\n\t{count} items with current tags\n")
 			continue
+
+		# option to create a new word (if word was not found in sorted language file)
 		if user_input == '4':
 			current_dict = create_word(current_dict,tags)
 			continue
+
+		# option for 'morphology table' functionality
+		# See readme and tables.py
 		elif user_input == 't':
 			tables.table_options(current_dict['language'])
-		else:
-			current_dict = look_up_word(user_input,current_dict,tags)
 # END ADD WORD OPTIONS
 
 
 # WORD OPTIONS
 # # # # # # # # # # # # # 
 def word_options(new_word,current_dict,backup,existing_word,t):
-	language = current_dict['language']
-	handle = new_word['handle']
+	''' User options for iteracting with a word retreived from 
+		sorted language files.
+	'''
+
+	# for brevity
 	heading = new_word['heading']
-	entry_string = ''
+
 	while True:
+		# get formatted string; may change between loop iterations
 		entry_string = get_entry_string(new_word['entries'])
-		if existing_word == True:
-
-			options = {'0':f"\n===================================================\n{heading} already exists in '{current_dict['file']}'\n",
-			'1':f"Do you want to save, edit or discard '{heading}'?\n",
-			'2':">>>(1=save, 2=edit, 0=discard)"}
-			#if 'template' not in new_word:
-			#	options.update({'t':"'T' to add templates\n"})
-			#else:
-			#	options.update({'t':"\n"})
-			options.update({'3':"'3' to see original wiktionary\n"})
+
+		# create user options
+
+		
+		if existing_word:
+			# display different message if word already exists in current dictionary
+			options = {'0':f"\n===================================================\n\
+			{heading} already exists in '{current_dict['file']}'\n",
+			'1':f"Do you want to save, edit or discard '{heading}'?\n"}
 		else:
+			# standard message for new words
 			options = {
-			'1':f"\n===================================================\nDo you want to save, edit or discard '{heading}'?\n",
-			'2':">>>(1=save, 2=edit, 0=discard)"}
-			#if 'template' not in new_word:
-			#	options.update({'t':" 'T' to add templates\n"})
-			#else:
-			#	options.update({'t':"\n"})
+			'1':f"\n===================================================\n\
+			Do you want to save, edit or discard '{heading}'?\n"}
+			options.update({'2':">>>(1=save, 2=edit, 0=discard)"})
+
+		# option to create a morphology flashcard template file
+		# and indicate that the table exists for future reference.
+		# currently disabled to avoid cluttering user options.
+		'''
+		if 'template' not in new_word:
+			options.update({'t':" 'T' to add templates\n"})
+		else:
+			options.update({'t':"\n"})
+		'''
+
+		# option to revert to unmodified definition from the sorted 
+		# language file for existing words
+		if existing_word:
+			options.update({'3':"'3' to see original wiktionary\n"})
+		else:
 			options.update({'0':''})
+
+		# validate user selection
 		user_input = get_selection(options,entry_string)
 
+		# option to go back
 		if user_input == '0':
 			return current_dict
 
+		# disabled option to create morphology flaschard template
 		elif user_input.lower() == 't':
 			tables.auto_template(current_dict,new_word)
 			if 'template' in new_word:
 				save_word(new_word,current_dict)
-				
+
+		# saved the word to current dictionary
 		elif user_input == '1':
 			save_word(new_word,current_dict)
 			return current_dict
 
+		# edit the definition
 		elif user_input == '2':
 			clear_screen()
 			new_word, finish_and_save = edit_entries(new_word,current_dict,t)
@@ -114,7 +168,9 @@ def word_options(new_word,current_dict,backup,existing_word,t):
 				save_word(new_word,current_dict)
 				return current_dict
 
+		# option to revert to original umodified definition
 		elif user_input == '3':
+			# should preserve 'template' tag after reverting
 			template = True if 'template' in new_word else False
 			new_word['entries'] = backup['entries']
 			if template:
@@ -125,80 +181,124 @@ def word_options(new_word,current_dict,backup,existing_word,t):
 # SAVE WORD
 # # # # # # # # # # # 
 def save_word(new_word,current_dict,mode=1):
+	'''	Add new_word to current_dict and saves updated current_dict
+		object to a file using pickle.dump method
+	'''
+
+	# not sure why this option is here
+	# SORTED_LANGUAGE_FILES should not be modified
 	if mode == 2:
-		load_dict.change_path('dumps_sorted')
+		change_path(SORTED_LANGUAGE_FILES)
 	else:
-		load_dict.change_path('dictionaries')
+		change_path(USER_CREATED_DICTIONARIES)
+	
+	# update the existing entry for the word by matching the handle
 	for i in range(len(current_dict['definitions'])):
 		if current_dict['definitions'][i]['handle'] == new_word['handle']:
+
+			# once the correct entry if found, overwrite the entry
 			current_dict['definitions'][i] = deepcopy(new_word)
+
+			# pickle.dump current_dict to file
 			with open(current_dict['file'],mode = 'wb') as openFile:
 				pickle.dump(current_dict, openFile)
+
+			# announce success and return
 			input(f"\n\"{new_word['heading']}\" was updated; press enter to continue")
 			return current_dict	
+
+	# existing entry not found: append and sort
 	current_dict['definitions'].append(deepcopy(new_word))
 	current_dict['definitions'].sort(key=lambda item: tables.replace_greek(item.get('handle').lower()))
+
+	# pickle.dump current_dict to file
 	with open(current_dict['file'],mode = 'wb') as openFile:
 		pickle.dump(current_dict, openFile)
 
+	# announce success and return
 	input(f"\n\"{new_word['heading']}\" was saved; press enter to continue")
 	return current_dict
 # END SAVE WORD
 
 
-def load_dump(language):
+def load_sorted_language(language):
+	'''	load datrie object from SORTED_LANGUAGE_FILES
+	'''
+
+	# loading may take several seconds for Latin
 	print(f"Loading {language}...")
 
-	load_dict.change_path("dumps_sorted")
+	change_path(SORTED_LANGUAGE_FILES)
 	with open(language.replace(" ","") + '-trie.txt','rb') as openFile:
 		t = pickle.load(openFile)
 	return t['definitions']
 
 
 def word_search(current_dict,tags):
+	'''	Call and handle returns from choose_from_trie function
+	'''
 
-	t = load_dump(current_dict['language'])
+	# load datrie containing sorted language
+	t = load_sorted_language(current_dict['language'])
 
 	while True:
-		""" Retrieve use selection from dictionary """ 
+		# Retrieve use selection from dictionary 
 		result = choose_from_trie(t,current_dict['language'])
 		clear_screen()
 
-		""" 'end' will be returned is user choose to end querying """
+		# 'end' will be returned is user choose to end querying
 		if result == None:
 			return current_dict
 
 		else:
-			""" Test if selected word already exists in saved dictionary """
+			# Test if selected word already exists in saved dictionary
 			existing_word = False
+
+			# save a back up of unmodified definition from sorted language file
 			backup = deepcopy(result)
+
+			# find a matching entry in current_dict if one exists
 			for i in range(len(current_dict['definitions'])):
 				if current_dict['definitions'][i]['handle'] == result['handle']:
 					existing_word = True
 					result = deepcopy(current_dict['definitions'][i])
+
+			# add current session tags to result
 			result['tags'] = result['tags'] | tags
+
+			# go to options for selected word
 			current_dict = word_options(result,current_dict,backup,existing_word,t)
 
 def center_text(text, total_width):
-    padding_each_side = (total_width - len(text.split('\n')[0])) // 2
-    lines = text.split('\n')
-    centered_lines = [f"{theme} " * ((padding_each_side - 2)//2) + line + f" {theme}" * ( (padding_each_side + 2)//2) + f" {theme}" for line in lines if line != '']
+	'''	Display text with equal amount of filler character 'theme' on both sides
+	'''
+	padding_each_side = (total_width - len(text.split('\n')[0])) // 2
+	lines = text.split('\n')
+	centered_lines = [f"{theme} " * ((padding_each_side - 2)//2) \
+		+ line + f" {theme}" * ( (padding_each_side + 2)//2)\
+		+ f" {theme}" for line in lines if line != '']
 
-    return '\n'.join(centered_lines)
+	return '\n'.join(centered_lines)
 
 def choose_from_trie(t,lang,debug_print=True):
+	''' Displays search window. Retreives words matching user search string
+		from datrie and prompts user selection from matching words.
+	'''
+	# user search string
 	prefix = ''
+
+	# collector for matching words
 	items = []
+
+	# flag when search turns up no results
 	empty = False
+
 	while True:
 		clear_screen()
 
-
 		# print heading
 		message = f"{theme} " * (75) + "\n"
 		asci_art = lang.upper() + " WORD SEARCH"
-		#if len(asci_art)%2 != 0:
-		#	asci_art += "!"
 		asci_art = figlet_format(asci_art,font='digital',width=150)
 		asci_art = center_text(asci_art,150)
 		message += asci_art + "\n"
@@ -207,104 +307,138 @@ def choose_from_trie(t,lang,debug_print=True):
 		message += "\n" + " "*148 + theme
 		print(message)
 
-
+		# display matching items, if any
 		if items:
 			print_word_list(items)
 
+		# display current search string
 		if prefix:
 			print(" " * 148 + theme)
 			message = f"Current filter: {prefix}-"
 			print("{:<148}".format(message) + theme)
 
+		# notify user the search string did not have any matches
 		if empty:
 			print(" " * 148 + theme)
 			print("{:<148}".format("! No items found with this combination") + theme)
 			print(" " * 148 + theme)
 			empty = False
 
-
+		# Display options menu
 		print("{:<148}".format("Options:") + theme)
 
+		# If options are visible, prompt user to choose a definition
 		if prefix:
 			print("{:<148}".format("Enter a number to select definition") + theme)
 
+		# prompt user to enter a search string, 
+		# instructions for how to limit the length of matching
 		print("{:<148}".format("Enter a search word or partial word (add one or more trailing '*'s to limit characters)") + theme)
+
+		# options to clear search string or quit
 		message = "Enter '0' to go back, '00' to "
 		if prefix:
 			message += "clear, '000' to "
 		message += "end"
+
+		# display message and wait for user input
 		print("{:<148}".format(message) + theme)
 		user_input = input(": ")
 
+		# validate user has input some value
 		if user_input == '':
 			continue
 
+		# 'go back' means remove last letter from search string
 		if user_input == '0':
 			prefix = prefix[:-1]
 
+		# option to clear search string
 		elif user_input == '00' and prefix:
 			prefix = ''
 			items = []
-			if debug_print:
-				print("\n" + theme * 15 + f"\n\nLINE: {current_line_number()}")
-				print(f"Prefix == {prefix}")
-				if prefix:
-					print(f"Prefix != ''")
-					exit()
 			continue
 
+		# option to quit
 		elif user_input == '00' or user_input == '000':
 			return None
 
+		# invisible option: entry with a leading 0 will overwrite previous search string
 		elif user_input[0] == '0':
 			prefix = user_input[1:]
 
+		# if nummeric value, user wants to select a word from search results
 		elif user_input.isnumeric():
+			# more data validation inside get_word
 			result = get_word(items,int(user_input))
+
+			# a valid selection was made
 			if result:
 				return result
 			else:
 				continue
+
+		# if none of the above apply, add user input to search string
 		else:
 			prefix += user_input
 
+		# if user is using a greek keyboard, the input must be converted to 
+		# asci before querying the trie
 		prefix = unidecode(prefix).lower()
 
+		# find the longest search string the matches a key in the trie
 		while not t.keys(prefix.replace('*','')):
 			prefix = prefix.replace('*','')[:-1]
 
+		# indicates no matches
 		if not prefix:
 			items = []
 			empty = True
 			continue
 
+		# get matching definition nodes as list
 		items = t.values(prefix.replace('*',''))
+
+		# find nodes containing multiple distinct definitions 
+		# and split them into multiple list items so that items 
+		# is a homogenous list of definition objects
 		items = flatten_sublists(items)
 
+		# if trailing '*'s user want to limit the length of words returned
 		if '*' in prefix:
+			# one '*' indicates exact match of length, multiple indicate within 1, 2 etc.
 			max_length = len(prefix) - 1
-			items = [item for item in items if len(item['heading']) <= max_length]
 
+			# eliminate overlength items from list
+			items = [item for item in items if len(item['heading']) <= max_length]
 
+			# if no items fit the maximum length
 			if not items:
 				empty = True
-				
 
 
 def flatten_sublists(lst):
+	'''	Remove sublists in items
+	'''
 	i = 0
+	# could use for loop here
 	while i < len(lst):
+		# If list encountered, stay on item until list is empty
 		while isinstance(lst[i], list):
+			# pop empty list
 			if not lst[i]:
 				lst.pop(i)
 				i -= 1
 				break
+			# Extend the main list with the elements of the sublist
 			else:
 				lst[i:i + 1] = lst[i]
 		i += 1
 	return lst
 
 def get_word(items,user_input):
+	'''	valide user selection and return selected word
+	'''
 	i = user_input - 1
 	if i in range(len(items)):
 		return items[i]
@@ -316,6 +450,8 @@ def visible_len(s):
     return len([c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn'])
 
 def print_word_list(items):
+	'''	Print search results in number list with consisted padding
+	'''
 	clear_screen()
 
 	# print heading
@@ -342,34 +478,48 @@ def print_word_list(items):
 		# Create and print formatted string
 		message = ''
 		for j in range(len(word['entries'])):
+
+			# print single entry words with just a number
 			if j == 0:
 				entry_string = f"{i + 1:>6}.  {word['heading']}:"
-				# print with desired alignment
-				#print(f"{entry_string:<30}",end='')
+
+			# print multiple entry words with number-letter indices
 			else:
 				entry_string = f"{i + 1:>6}{chr(j + 97)}. {word['heading']}:"
-			message += f"{entry_string:<30}"
-				# print with desired alignment
-				#print(f"{entry_string:<30}",end='')				
 
+			# add padding to entry string
+			message += f"{entry_string:<30}"		
+
+			# add preview of top word senses
 			text = word['entries'][j]['senses']
+
+			# word contains a single sense
 			if len(text) == 1:
 				entry_len = len(text[0]['gloss'])
 				entry_string = text[0]['gloss']
+
+			# if word contains multiple senses
 			else:
 				entry_len = sum([len(f"0) " + text[i]['gloss'] + "  ") for i in range(len(text))])
 				entry_string = ''
 				for line in [f"{i + 1}) " + text[i]['gloss'] + "  " for i in range(len(text))]:
 					entry_string += line
+
+			# limit to 100 chars
 			entry_string = entry_string[:100]
 
 			# if over length attach elipses
 			if entry_len > 100:
 				entry_string = entry_string[:-3]
 				entry_string += "..."
+
 			message += f"{entry_string}"
+
+			# ensure correct padding for all alphabets
 			while visible_len(message) < 148:
 				message += " "
+
+			# print and reset message
 			print(message + theme)
 			message = ''
 
diff --git a/src/perseus_xml_utilities.py b/src/perseus_xml_utilities.py
new file mode 100644
index 0000000..6661a39
--- /dev/null
+++ b/src/perseus_xml_utilities.py
@@ -0,0 +1,187 @@
+'''
+Utility function for parsing xml files of "Middle Liddell" and "LSJ" lexicons
+Imported by dictionary_LSJ.py and dictionary_Middle_Liddel.py
+'''
+import beta_code
+from copy import deepcopy
+
+debug_print = False
+
+# Print Progress
+def printpr(counter, modulo=10000):
+	if counter % modulo == 0:
+		print(".",end='',flush=True)
+	if counter % (modulo*100) == 0:
+		print(f' {counter:,} lines parsed',flush=True)
+
+def cut_text(text,start,stop):
+	'''	cut string according to start and stop integer arguments
+	'''
+	p = text.find(start) + len(start)
+	text = text[p:]
+	text = text[:text.find(stop)]
+	return text
+
+def translate_greek(text,bold):
+	''' convert beta code to unicode
+	'''
+	text = list(text)
+	text = [x for x in text if not x.isnumeric()]
+	text = "".join(text)
+	if bold:
+		return "<b>" + beta_code.beta_code_to_greek(text) + "</b>"
+	else:
+		return beta_code.beta_code_to_greek(text)
+
+def smart_join(text):
+	'''	Fixes recurring errors in spacing after punctuation from get_defs algorithm
+	'''
+	s = ""
+	for i in range(len(text)):
+		if i == 0:
+			s = text[i]
+		else:
+			if s[-1] != " " and s[-1] not in ['('] and text[i][0] != " " and text[i][0] not in [',','.',';',')','?']:
+				s += " " + text[i]
+			else:
+				s += text[i]
+	return s.replace(" .",".").replace(" ,",",").replace(" :",":")
+
+
+def configure_parts(senses):
+	'''	somehow compiles principle parts from top lines of senses.
+		Need to review this code and comment in more detail.
+	'''
+	count = 0
+
+	for i in senses[0]['gloss']:
+		if i == "(":
+			count += 1
+
+		if i == ")" and count != 0:
+			count -= 1
+
+		if count < 0:
+			# Error too many )s, unbalanced parens
+			print(senses[0]['gloss'])
+			print(senses[1]['gloss'])
+			break
+
+	if count != 0:
+		parens = 0
+
+		for i in range(len(senses[1]['gloss'])):
+			if senses[1]['gloss'][i] == ")":
+				parens += 1
+
+			if senses[1]['gloss'][i] == "(":
+				parens -= 1
+
+			if parens == count:
+				break
+
+		if i < len(senses[1]['gloss']) - 1:
+			senses[0]['gloss'] = smart_join([senses[0]['gloss'],senses[1]['gloss'][: i + 1]])
+			senses[1]['gloss'] = senses[1]['gloss'][i + 1 :]
+
+			for i in range(len(senses[1]['gloss'])):
+				if senses[1]['gloss'][i].isalpha() or senses[1]['gloss'][i] == "=":
+					break
+			senses[1]['gloss'] = senses[1]['gloss'][i:]
+		else:
+			senses[0]['gloss'] += ")"
+
+	return senses
+
+def process_entry(text,tag):
+	''' Process a definition from the persues file to find the
+		pieces corresponding to the word-hoarder defintiion data structure
+	'''
+
+	'''	create the blank data structures
+		definitions will have only one entry until they are deplicated and combined
+	'''
+	definition = {'heading':'',
+				'handle':'',
+				'tags':set(),
+				'entries':[]}
+
+	entry = {'senses':[],
+			'partOfSpeech':'',
+			'principleParts':'',
+			'simpleParts':'',
+			'etymology':''}
+
+	# key contains the handle
+	handle = cut_text(text,"key=\"","\"")
+	definition['heading'] = definition['handle'] = translate_greek(handle,bold=False)
+	
+	'''	debug_print blasts out a massive amount of text showing what is being 
+		assigned to what
+	'''
+	if debug_print:
+		print("@"*5000 + f"\nheading \"{definition['heading']}\"")
+
+	# get_def takes bites off remaining text until it is empty
+	while text != "":
+		text, senses = get_def(text)
+
+		for x in senses:
+			if debug_print:
+				print(f"definition: {x['gloss']}")
+			entry['senses'].append(deepcopy(x))
+
+	'''	top line of definition contains the principles parts in some cases 
+		and not in othes
+	'''
+	if len(entry['senses']) > 1:
+		entry['senses'] = configure_parts(entry['senses'])
+		entry['simpleParts'] = entry["principleParts"] = entry['senses'][0]['gloss']
+		entry['senses'].pop(0)
+	else:
+		entry['simpleParts'] = entry["principleParts"] = definition['heading']
+
+	definition['entries'].append(deepcopy(entry))
+	definition['tags'].add(tag)
+	return definition
+
+def get_def(text):
+	'''	Uses xml tags to recognize beginning and ending of senses
+		Also spots greek beta code that needs to be translated
+	'''
+	m = 0
+	gloss = []
+	senses = []
+	greek = False
+	candidate_tag = ''
+	while True:
+		pull = text[:text.find("<")]
+		brac = text[text.find("<"):text.find(">")+1]
+		text = text[text.find(">") + 1:]
+
+		if greek and pull != "":
+			pull = translate_greek(pull,bold=True)
+			greek = False
+
+		if 'lang=\"greek\"' in brac:
+			greek = True
+
+		if "<sense" in brac:
+			gloss = smart_join(gloss).strip(",. ")
+			if gloss != "":
+				senses.append({'gloss':gloss,'tags':[]})
+			gloss = []
+
+		if pull != "":
+			gloss.append(deepcopy(pull))
+
+		if brac == "</sense>" or text == "":
+			gloss = smart_join(gloss).strip(",. ")
+			if gloss != "":
+				senses.append({'gloss':gloss,'tags':[]})
+			break
+
+	return text, senses
+
+
+
diff --git a/src/tables.py b/src/tables.py
index aceb0f0..6afddd1 100644
--- a/src/tables.py
+++ b/src/tables.py
@@ -1,7 +1,7 @@
 import json, pickle
 import glob
 import os
-from load_dict import change_path
+from load_dict import change_path, FLASHCARD_TEMPLATE_FILES
 from get_selection import get_selection
 from unidecode import unidecode
 from copy import deepcopy
@@ -18,7 +18,7 @@ def debug_print(message):
 		print(f"[Line {line_number}] - {message}")
 
 def get_tables(language):
-	change_path('tables')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	table_file = language.replace(" ","") + "-tables.txt"
 	if table_file not in myFiles:
@@ -30,7 +30,7 @@ def get_tables(language):
 		return tables_list
 
 def get_forms(language):
-	change_path('tables')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	form_file = language.replace(" ","") + "-forms.txt"
 	if form_file not in myFiles:
@@ -163,7 +163,7 @@ def replace_greek_ii(word):
 
 
 def save_tables(tables_list,file):
-	change_path('tables')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	with open(file,'w') as f:
 		json.dump(tables_list,f)
 
@@ -202,32 +202,11 @@ def table_options(language):
 			template_options(language)
 		elif user_input == '0':
 			return
-'''
-def template_options(language):
-	print('re-doing all templates')
-	change_path('templates')
-	myFiles = glob.glob('*.txt')
-	template_file = language.replace(" ","") + "_templates.txt"
-	if template_file not in myFiles:
-		templates = []
-	else:
-		with open(template_file,'r') as f:
-			templates = json.load(f)
-	for t in templates:
-		if t['POS'] == 'verb':
-			t = tables_greek_ext.get_forms(t)
 
-	change_path('templates')
-	sort_tables(templates,language)
-	with open(template_file,'w') as f:
-		json.dump(templates,f)
 
-	print('re-doing all templates succesful')
-	return
-'''
 def template_options(language):
 	while True:
-		change_path('templates')
+		change_path(FLASHCARD_TEMPLATE_FILES)
 		myFiles = glob.glob('*.txt')
 		template_file = language.replace(" ","") + "_templates.txt"
 		if template_file not in myFiles:
@@ -257,7 +236,7 @@ def template_options(language):
 						edit_template(templates[i],language)
 						break
 
-		change_path('templates')
+		change_path(FLASHCARD_TEMPLATE_FILES)
 		sort_tables(templates,language)
 		with open(template_file,'w') as f:
 			json.dump(templates,f)
@@ -296,7 +275,7 @@ def get_template_options(templates):
 	return options, keys
 
 def auto_template(dictionary,word):
-	change_path('templates')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	language = dictionary['language']
 	template_file = language.replace(" ","") + "_templates.txt"
@@ -327,7 +306,7 @@ def auto_template(dictionary,word):
 			if template:
 				templates.append(template)
 
-	change_path('templates')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	sort_tables(templates,language)
 	with open(template_file,'w') as f:
 		json.dump(templates,f)
@@ -388,7 +367,7 @@ def short_line(line,limit):
 	return line
 
 def get_template(language):
-	change_path('templates')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	template_file = language.replace(" ","") + "_templates.txt"
 	if template_file not in myFiles:
@@ -615,26 +594,4 @@ def print_tables(tables_list,language):
 	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]['senses'][number]['gloss']
-			if selection == None:
-				return None
-			else:
-				return definition
-'''
\ No newline at end of file
diff --git a/src/tables_greek_ext.py b/src/tables_greek_ext.py
index 7df8fbf..844e2f2 100644
--- a/src/tables_greek_ext.py
+++ b/src/tables_greek_ext.py
@@ -2,7 +2,7 @@
 from bs4 import BeautifulSoup
 import tables
 import flashcard_html_utilities
-from load_dict import change_path
+from load_dict import change_path, FORMATTED_FLASHCARD_FILES, FLASHCARD_TEMPLATE_FILES
 from get_selection import get_selection
 from copy import deepcopy, copy
 import random
@@ -915,7 +915,7 @@ def add_tables():
 						return
 
 def auto_add(tables_list,table_info,table_file):
-	change_path('templates')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	template_file = "AncientGreek_templates.txt"
 	if template_file not in myFiles:
@@ -1253,7 +1253,7 @@ def features_join(features):
 def print_forms():
 	out_file = 'AncientGreek-FormCards.txt'
 	original_stdout = sys.stdout 
-	change_path('flashcards')
+	change_path(FORMATTED_FLASHCARD_FILES)
 	sys.stdout = open(out_file,'w')
 	forms_list = tables.get_forms("Ancient Greek")
 	random_list = list(range(len(forms_list)))
@@ -1277,7 +1277,7 @@ def print_tables(tables_list):
 	print_forms()
 	out_file = 'AncientGreek-TableCards.txt'
 	original_stdout = sys.stdout 
-	change_path('flashcards')
+	change_path(FORMATTED_FLASHCARD_FILES)
 	sys.stdout = open(out_file,'w')
 	random_list = list(range(len(tables_list)))
 	random.shuffle(random_list)
diff --git a/src/tables_latin_ext.py b/src/tables_latin_ext.py
index dca3f68..f10b0f6 100644
--- a/src/tables_latin_ext.py
+++ b/src/tables_latin_ext.py
@@ -2,7 +2,7 @@
 from bs4 import BeautifulSoup
 
 import tables
-from load_dict import change_path
+from load_dict import change_path, FORMATTED_FLASHCARD_FILES, FLASHCARD_TEMPLATE_FILES, SUPPLEMENTARY_LANGUAGE_FILES
 from get_selection import get_selection
 from copy import deepcopy
 from unidecode import unidecode
@@ -269,7 +269,7 @@ def inside_out_noun(parts):
 	return forms
 
 def inside_out_verb(parts):
-	change_path("texts")
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 	with open('sum_forms.txt','r') as f:
 		sum_forms = json.load(f)
 	if parts['Present']['Active']['Indicative']['FPS'] == "sum":
@@ -662,7 +662,7 @@ def retreive_noun_forms(template):
 	return cases
 
 def add_sum_forms(page_list,i,alt=''):
-	change_path('texts')
+	change_path(SUPPLEMENTARY_LANGUAGE_FILES)
 	with open('sum_parts.txt','r') as f:
 		sum_forms = json.load(f)
 	if 'Imperfect' in page_list[i - 1].title():
@@ -788,7 +788,7 @@ def add_tables():
 						return
 
 def auto_add(tables_list,table_info,table_file):
-	change_path('templates')
+	change_path(FLASHCARD_TEMPLATE_FILES)
 	myFiles = glob.glob('*.txt')
 	template_file = "Latin_templates.txt"
 	if template_file not in myFiles:
@@ -1048,7 +1048,7 @@ def features_join(features):
 def print_forms():
 	out_file = 'Latin-FormCards.txt'
 	original_stdout = sys.stdout 
-	change_path('flashcards')
+	change_path(FORMATTED_FLASHCARD_FILES)
 	sys.stdout = open(out_file,'w')
 	forms_list = tables.get_forms("Latin")
 	random_list = list(range(len(forms_list)))
@@ -1071,11 +1071,9 @@ def print_tables(tables_list):
 	print_forms()
 	out_file = 'Latin-TableCards.txt'
 	original_stdout = sys.stdout 
-	change_path('flashcards')
+	change_path(FORMATTED_FLASHCARD_FILES)
 	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)):
 		
 
diff --git a/src/tables_oe_ext.py b/src/tables_oe_ext.py
index e61a5f9..22f4d1d 100644
--- a/src/tables_oe_ext.py
+++ b/src/tables_oe_ext.py
@@ -2,7 +2,7 @@
 from bs4 import BeautifulSoup
 import tables
 import flashcard_html_utilities
-from load_dict import change_path
+from load_dict import change_path, FORMATTED_FLASHCARD_FILES
 from get_selection import get_selection
 from copy import deepcopy
 import random
@@ -276,7 +276,7 @@ def clean_page_list(page_list):
 def print_tables(tables_list):
 	out_file = 'OldEnglishflashcardtables.txt'
 	original_stdout = sys.stdout 
-	change_path('flashcards')
+	change_path(FORMATTED_FLASHCARD_FILES)
 	sys.stdout = open(out_file,'w')
 	random_list = list(range(len(tables_list)))
 	random.shuffle(random_list)
diff --git a/src/word_methods.py b/src/word_methods.py
index cb100ce..3867f31 100644
--- a/src/word_methods.py
+++ b/src/word_methods.py
@@ -1,18 +1,4 @@
 
-'''
-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
diff --git a/src/word_print_edit.py b/src/word_print_edit.py
index 3642b60..ef7dd39 100644
--- a/src/word_print_edit.py
+++ b/src/word_print_edit.py
@@ -1,4 +1,3 @@
-
 '''
 Description:
 
diff --git a/dumps_sorted/Latin-i_stem_nouns-trie.txt b/supplementary_language_files/Latin-i_stem_nouns-trie.txt
similarity index 100%
rename from dumps_sorted/Latin-i_stem_nouns-trie.txt
rename to supplementary_language_files/Latin-i_stem_nouns-trie.txt
diff --git a/texts/MLJohnson_OEDictionary.txt b/supplementary_language_files/MLJohnson_OEDictionary.txt
similarity index 100%
rename from texts/MLJohnson_OEDictionary.txt
rename to supplementary_language_files/MLJohnson_OEDictionary.txt
diff --git a/texts/ignore_tags.txt b/supplementary_language_files/ignore_tags.txt
similarity index 100%
rename from texts/ignore_tags.txt
rename to supplementary_language_files/ignore_tags.txt
diff --git a/texts/sum_forms.txt b/supplementary_language_files/sum_forms.txt
similarity index 100%
rename from texts/sum_forms.txt
rename to supplementary_language_files/sum_forms.txt
diff --git a/texts/sum_parts.txt b/supplementary_language_files/sum_parts.txt
similarity index 100%
rename from texts/sum_parts.txt
rename to supplementary_language_files/sum_parts.txt