import streamlit as st
import yaml, os, json, random, time, re, torch, random, warnings, shutil, sys, glob
import seaborn as sns
import plotly.graph_objs as go
from PIL import Image
import pandas as pd
from io import BytesIO
# from streamlit_extras.let_it_rain import rain
from annotated_text import annotated_text
from vouchervision.LeafMachine2_Config_Builder import write_config_file
from vouchervision.VoucherVision_Config_Builder import build_VV_config, TestOptionsGPT, TestOptionsPalm, check_if_usable
from vouchervision.vouchervision_main import voucher_vision
from vouchervision.general_utils import test_GPU, get_cfg_from_full_path, summarize_expense_report, validate_dir
from vouchervision.model_maps import ModelMaps
from vouchervision.API_validation import APIvalidation
from vouchervision.utils_hf import setup_streamlit_config, save_uploaded_file, save_uploaded_local, save_uploaded_file_local
from vouchervision.data_project import convert_pdf_to_jpg
from vouchervision.utils_LLM import check_system_gpus
from vouchervision.OCR_google_cloud_vision import SafetyCheck
import cProfile
import pstats
#################################################################################################################################################
# Initializations ###############################################################################################################################
#################################################################################################################################################
st.set_page_config(layout="wide", page_icon='img/icon.ico', page_title='VoucherVision',initial_sidebar_state="collapsed")
# Parse the 'is_hf' argument and set it in session state
if 'is_hf' not in st.session_state:
is_hf_os = os.getenv('IS_HF', '').lower() # Get the environment variable and convert to lowercase for uniformity
print(f"=== os.getenv('IS_HF', '').lower() ===> {is_hf_os} ===")
if is_hf_os in ['1', 'true']: # Check against string representations of truthy values
st.session_state['is_hf'] = True
else:
st.session_state['is_hf'] = False
print(f"=== is_hf {st.session_state['is_hf']} ===")
# Default YAML file path
if 'config' not in st.session_state:
st.session_state.config, st.session_state.dir_home = build_VV_config(loaded_cfg=None)
setup_streamlit_config(st.session_state.dir_home)
# st.session_state['is_hf'] = True
########################################################################################################
### Global constants ####
########################################################################################################
MAX_GALLERY_IMAGES = 20
GALLERY_IMAGE_SIZE = 96
########################################################################################################
### Init funcs ####
########################################################################################################
def does_private_file_exist():
dir_home = os.path.dirname(__file__)
path_cfg_private = os.path.join(dir_home, 'PRIVATE_DATA.yaml')
return os.path.exists(path_cfg_private)
########################################################################################################
### Streamlit inits [FOR SAVE FILE] ####
########################################################################################################
########################################################################################################
### Streamlit inits [routing] ####
########################################################################################################
if st.session_state['is_hf']:
if 'proceed_to_main' not in st.session_state:
st.session_state.proceed_to_main = True
if 'proceed_to_private' not in st.session_state:
st.session_state.proceed_to_private = False
if 'private_file' not in st.session_state:
st.session_state.private_file = True
else:
if 'proceed_to_main' not in st.session_state:
st.session_state.proceed_to_main = False # New state variable to control the flow
if 'private_file' not in st.session_state:
st.session_state.private_file = does_private_file_exist()
if st.session_state.private_file:
st.session_state.proceed_to_main = True
if 'proceed_to_private' not in st.session_state:
st.session_state.proceed_to_private = False # New state variable to control the flow
if 'proceed_to_build_llm_prompt' not in st.session_state:
st.session_state.proceed_to_build_llm_prompt = False # New state variable to control the flow
if 'proceed_to_build_llm_prompt' not in st.session_state:
st.session_state.proceed_to_build_llm_prompt = False
if 'proceed_to_component_detector' not in st.session_state:
st.session_state.proceed_to_component_detector = False
if 'proceed_to_parsing_options' not in st.session_state:
st.session_state.proceed_to_parsing_options = False
if 'proceed_to_api_keys' not in st.session_state:
st.session_state.proceed_to_api_keys = False
if 'proceed_to_space_saver' not in st.session_state:
st.session_state.proceed_to_space_saver = False
if 'proceed_to_faqs' not in st.session_state:
st.session_state.proceed_to_faqs = False
########################################################################################################
### Streamlit inits [basics] ####
########################################################################################################
if 'processing_add_on' not in st.session_state:
st.session_state['processing_add_on'] = 0
if 'capability_score' not in st.session_state:
st.session_state['num_gpus'], st.session_state['gpu_dict'], st.session_state['total_vram_gb'], st.session_state['capability_score'] = check_system_gpus()
if 'formatted_json' not in st.session_state:
st.session_state['formatted_json'] = None
if 'formatted_json_WFO' not in st.session_state:
st.session_state['formatted_json_WFO'] = None
if 'formatted_json_GEO' not in st.session_state:
st.session_state['formatted_json_GEO'] = None
if 'lacks_GPU' not in st.session_state:
st.session_state['lacks_GPU'] = not torch.cuda.is_available()
if 'API_key_validation' not in st.session_state:
st.session_state['API_key_validation'] = False
if 'API_checked' not in st.session_state:
st.session_state['API_checked'] = False
if 'API_rechecked' not in st.session_state:
st.session_state['API_rechecked'] = False
if 'present_annotations' not in st.session_state:
st.session_state['present_annotations'] = None
if 'missing_annotations' not in st.session_state:
st.session_state['missing_annotations'] = None
if 'date_of_check' not in st.session_state:
st.session_state['date_of_check'] = None
if 'json_report' not in st.session_state:
st.session_state['json_report'] = False
if 'hold_output' not in st.session_state:
st.session_state['hold_output'] = False
if 'cost_openai' not in st.session_state:
st.session_state['cost_openai'] = None
if 'cost_azure' not in st.session_state:
st.session_state['cost_azure'] = None
if 'cost_google' not in st.session_state:
st.session_state['cost_google'] = None
if 'cost_mistral' not in st.session_state:
st.session_state['cost_mistral'] = None
if 'cost_local' not in st.session_state:
st.session_state['cost_local'] = None
if 'settings_filename' not in st.session_state:
st.session_state['settings_filename'] = None
if 'loaded_settings_filename' not in st.session_state:
st.session_state['loaded_settings_filename'] = None
if 'zip_filepath' not in st.session_state:
st.session_state['zip_filepath'] = None
########################################################################################################
### Streamlit inits [prompt builder] ####
########################################################################################################
# These are the fields that are in SLTPvA that are not required by another parsing valication function:
# "identifiedBy": "M.W. Lyon, Jr.",
# "recordedBy": "University of Michigan Herbarium",
# "recordNumber": "",
# "habitat": "wet subdunal woods",
# "occurrenceRemarks": "Indiana : Porter Co.",
# "degreeOfEstablishment": "",
# "minimumElevationInMeters": "",
# "maximumElevationInMeters": ""
if 'required_fields' not in st.session_state:
st.session_state['required_fields'] = ['catalogNumber','order','family','scientificName',
'scientificNameAuthorship','genus','subgenus','specificEpithet','infraspecificEpithet',
'verbatimEventDate','eventDate',
'country','stateProvince','county','municipality','locality','decimalLatitude','decimalLongitude','verbatimCoordinates',]
if 'prompt_info' not in st.session_state:
st.session_state['prompt_info'] = {}
if 'rules' not in st.session_state:
st.session_state['rules'] = {}
########################################################################################################
### Streamlit inits [gallery] ####
########################################################################################################
if 'uploader_idk' not in st.session_state:
st.session_state['uploader_idk'] = 1
if 'input_list_small' not in st.session_state:
st.session_state['input_list_small'] = []
if 'input_list' not in st.session_state:
st.session_state['input_list'] = []
if 'user_clicked_load_prompt_yaml' not in st.session_state:
st.session_state['user_clicked_load_prompt_yaml'] = None
if 'new_prompt_yaml_filename' not in st.session_state:
st.session_state['new_prompt_yaml_filename'] = None
if 'view_local_gallery' not in st.session_state:
st.session_state['view_local_gallery'] = False
if 'dir_images_local_TEMP' not in st.session_state:
st.session_state['dir_images_local_TEMP'] = False
if 'dir_uploaded_images' not in st.session_state:
st.session_state['dir_uploaded_images'] = os.path.join(st.session_state.dir_home,'uploads')
validate_dir(os.path.join(st.session_state.dir_home,'uploads'))
if 'dir_uploaded_images_small' not in st.session_state:
st.session_state['dir_uploaded_images_small'] = os.path.join(st.session_state.dir_home,'uploads_small')
validate_dir(os.path.join(st.session_state.dir_home,'uploads_small'))
########################################################################################################
### CONTENT [] ####
########################################################################################################
@st.cache_data
def show_gallery_small():
st.image(st.session_state['input_list_small'], width=GALLERY_IMAGE_SIZE)
@st.cache_data
def show_gallery_small_hf(images_to_display):
print(images_to_display)
st.image(images_to_display)
@st.cache_data
def load_gallery(converted_files, uploaded_file):
for file_name in converted_files:
if file_name.lower().endswith('.jpg'):
jpg_file_path = os.path.join(st.session_state['dir_uploaded_images'], file_name)
st.session_state['input_list'].append(jpg_file_path)
# Optionally, create a thumbnail for the gallery
img = Image.open(jpg_file_path)
img.thumbnail((GALLERY_IMAGE_SIZE, GALLERY_IMAGE_SIZE), Image.Resampling.LANCZOS)
file_path_small = save_uploaded_file(st.session_state['dir_uploaded_images_small'], uploaded_file, img)
st.session_state['input_list_small'].append(file_path_small)
@st.cache_data
def handle_image_upload_and_gallery_hf(uploaded_files):
SAFE = SafetyCheck(st.session_state['is_hf'])
if uploaded_files:
# Clear input image gallery and input list
clear_image_uploads()
ind_small = 0
for uploaded_file in uploaded_files:
if SAFE.check_for_inappropriate_content(uploaded_file):
clear_image_uploads()
st.error("Warning: You have uploaded an inappropriate image")
return True
# Determine the file type
if uploaded_file.name.lower().endswith('.pdf'):
# Handle PDF files
file_path = save_uploaded_file(st.session_state['dir_uploaded_images'], uploaded_file)
# Convert each page of the PDF to an image
n_pages = convert_pdf_to_jpg(file_path, st.session_state['dir_uploaded_images'], dpi=200)#st.session_state.config['leafmachine']['project']['dir_images_local'])
# Update the input list for each page image
converted_files = os.listdir(st.session_state['dir_uploaded_images'])
for file_name in converted_files:
if file_name.split('.')[1].lower() in ['jpg','jpeg']:
ind_small += 1
jpg_file_path = os.path.join(st.session_state['dir_uploaded_images'], file_name)
st.session_state['input_list'].append(jpg_file_path)
if ind_small < MAX_GALLERY_IMAGES +5:
# Optionally, create a thumbnail for the gallery
img = Image.open(jpg_file_path)
img.thumbnail((GALLERY_IMAGE_SIZE, GALLERY_IMAGE_SIZE), Image.Resampling.LANCZOS)
try:
file_path_small = save_uploaded_file(st.session_state['dir_uploaded_images_small'], file_name, img)
except:
file_path_small = save_uploaded_file_local(st.session_state['dir_uploaded_images_small'],st.session_state['dir_uploaded_images_small'], file_name, img)
st.session_state['input_list_small'].append(file_path_small)
else:
ind_small += 1
# Handle JPG/JPEG files (existing process)
file_path = save_uploaded_file(st.session_state['dir_uploaded_images'], uploaded_file)
st.session_state['input_list'].append(file_path)
if ind_small < MAX_GALLERY_IMAGES +5:
img = Image.open(file_path)
img.thumbnail((GALLERY_IMAGE_SIZE, GALLERY_IMAGE_SIZE), Image.Resampling.LANCZOS)
file_path_small = save_uploaded_file(st.session_state['dir_uploaded_images_small'], uploaded_file, img)
st.session_state['input_list_small'].append(file_path_small)
# After processing all files
st.session_state.config['leafmachine']['project']['dir_images_local'] = st.session_state['dir_uploaded_images']
st.info(f"Processing images from {st.session_state.config['leafmachine']['project']['dir_images_local']}")
if st.session_state['input_list_small']:
if len(st.session_state['input_list_small']) > MAX_GALLERY_IMAGES:
# Only take the first 100 images from the list
images_to_display = st.session_state['input_list_small'][:MAX_GALLERY_IMAGES]
else:
# If there are less than 100 images, take them all
images_to_display = st.session_state['input_list_small']
show_gallery_small_hf(images_to_display)
return False
@st.cache_data
def handle_image_upload_and_gallery():
if st.session_state['view_local_gallery'] and st.session_state['input_list_small'] and (st.session_state['dir_images_local_TEMP'] == st.session_state.config['leafmachine']['project']['dir_images_local']):
if MAX_GALLERY_IMAGES <= st.session_state['processing_add_on']:
info_txt = f"Showing {MAX_GALLERY_IMAGES} out of {st.session_state['processing_add_on']} images"
else:
info_txt = f"Showing {st.session_state['processing_add_on']} out of {st.session_state['processing_add_on']} images"
st.info(info_txt)
try:
show_gallery_small()
except:
pass
elif not st.session_state['view_local_gallery'] and st.session_state['input_list_small'] and (st.session_state['dir_images_local_TEMP'] == st.session_state.config['leafmachine']['project']['dir_images_local']):
pass
elif not st.session_state['view_local_gallery'] and not st.session_state['input_list_small'] and (st.session_state['dir_images_local_TEMP'] == st.session_state.config['leafmachine']['project']['dir_images_local']):
pass
# elif st.session_state['input_list_small'] and (st.session_state['dir_images_local_TEMP'] != st.session_state.config['leafmachine']['project']['dir_images_local']):
elif (st.session_state['dir_images_local_TEMP'] != st.session_state.config['leafmachine']['project']['dir_images_local']):
has_pdf = False
clear_image_uploads()
for input_file in os.listdir(st.session_state.config['leafmachine']['project']['dir_images_local']):
if input_file.split('.')[1].lower() in ['jpg','jpeg']:
pass
elif input_file.split('.')[1].lower() in ['pdf',]:
has_pdf = True
# Handle PDF files
file_path = save_uploaded_file_local(st.session_state.config['leafmachine']['project']['dir_images_local'], st.session_state['dir_uploaded_images'], input_file)
# Convert each page of the PDF to an image
n_pages = convert_pdf_to_jpg(file_path, st.session_state['dir_uploaded_images'], dpi=200)#st.session_state.config['leafmachine']['project']['dir_images_local'])
else:
pass
# st.warning("Inputs must be '.PDF' or '.jpg' or '.jpeg'")
if has_pdf:
st.session_state.config['leafmachine']['project']['dir_images_local'] = st.session_state['dir_uploaded_images']
dir_images_local = st.session_state.config['leafmachine']['project']['dir_images_local']
count_n_imgs = list_jpg_files(dir_images_local)
st.session_state['processing_add_on'] = count_n_imgs
# print(st.session_state['processing_add_on'])
st.session_state['dir_images_local_TEMP'] = st.session_state.config['leafmachine']['project']['dir_images_local']
print("rerun")
st.rerun()
def content_input_images(col_left, col_right):
st.write('---')
# col1, col2 = st.columns([2,8])
with col_left:
st.header('Input Images')
if not st.session_state.is_hf:
### Input Images Local
st.session_state.config['leafmachine']['project']['dir_images_local'] = st.text_input("Input images directory", st.session_state.config['leafmachine']['project'].get('dir_images_local', ''))
st.session_state.config['leafmachine']['project']['continue_run_from_partial_xlsx'] = st.text_input("Continue run from partially completed project XLSX", st.session_state.config['leafmachine']['project'].get('continue_run_from_partial_xlsx', ''), disabled=True)
else:
pass
with col_left:
if st.session_state.is_hf:
st.session_state['dir_uploaded_images'] = os.path.join(st.session_state.dir_home,'uploads')
st.session_state['dir_uploaded_images_small'] = os.path.join(st.session_state.dir_home,'uploads_small')
uploaded_files = st.file_uploader("Upload Images", type=['jpg', 'jpeg','pdf'], accept_multiple_files=True, key=st.session_state['uploader_idk'])
st.button("Use Test Image",help="This will clear any uploaded images and load the 1 provided test image.",on_click=use_test_image)
with col_right:
if st.session_state.is_hf:
result = handle_image_upload_and_gallery_hf(uploaded_files)
else:
st.session_state['view_local_gallery'] = st.toggle("View Image Gallery",)
handle_image_upload_and_gallery()
def list_jpg_files(directory_path):
jpg_count = 0
clear_image_gallery()
st.session_state['input_list_small'] = []
if not os.path.isdir(directory_path):
return None
jpg_count = count_jpg_images(directory_path)
jpg_files = []
for root, dirs, files in os.walk(directory_path):
for file in files:
if file.lower().endswith('.jpg'):
jpg_files.append(os.path.join(root, file))
if len(jpg_files) == MAX_GALLERY_IMAGES:
break
if len(jpg_files) == MAX_GALLERY_IMAGES:
break
for simg in jpg_files:
simg2 = Image.open(simg)
simg2.thumbnail((GALLERY_IMAGE_SIZE, GALLERY_IMAGE_SIZE), Image.Resampling.LANCZOS)
file_path_small = save_uploaded_local(st.session_state['dir_uploaded_images_small'], simg, simg2)
st.session_state['input_list_small'].append(file_path_small)
return jpg_count
def count_jpg_images(directory_path):
if not os.path.isdir(directory_path):
return None
jpg_count = 0
for root, dirs, files in os.walk(directory_path):
for file in files:
if file.lower().endswith('.jpg'):
jpg_count += 1
return jpg_count
def create_download_button(zip_filepath, col, key):
with col:
# labal_n_images = f"Download Results for {st.session_state['processing_add_on']} Images"
labal_n_images = f"Download Results"
with open(zip_filepath, 'rb') as f:
bytes_io = BytesIO(f.read())
st.download_button(
label=labal_n_images,
type='primary',
data=bytes_io,
file_name=os.path.basename(zip_filepath),
mime='application/zip',
use_container_width=True,key=key,
)
def delete_directory(dir_path):
try:
shutil.rmtree(dir_path)
st.session_state['input_list'] = []
st.session_state['input_list_small'] = []
# st.success(f"Deleted previously uploaded images, making room for new images: {dir_path}")
except OSError as e:
st.error(f"Error: {dir_path} : {e.strerror}")
def clear_image_gallery():
delete_directory(st.session_state['dir_uploaded_images_small'])
validate_dir(st.session_state['dir_uploaded_images_small'])
def clear_image_uploads():
delete_directory(st.session_state['dir_uploaded_images'])
delete_directory(st.session_state['dir_uploaded_images_small'])
validate_dir(st.session_state['dir_uploaded_images'])
validate_dir(st.session_state['dir_uploaded_images_small'])
def use_test_image():
st.info(f"Processing images from {os.path.join(st.session_state.dir_home,'demo','demo_images')}")
st.session_state.config['leafmachine']['project']['dir_images_local'] = os.path.join(st.session_state.dir_home,'demo','demo_images')
n_images = len([f for f in os.listdir(st.session_state.config['leafmachine']['project']['dir_images_local']) if os.path.isfile(os.path.join(st.session_state.config['leafmachine']['project']['dir_images_local'], f))])
st.session_state['processing_add_on'] = n_images
clear_image_uploads()
st.session_state['uploader_idk'] += 1
for file in os.listdir(st.session_state.config['leafmachine']['project']['dir_images_local']):
try:
file_path = save_uploaded_file(os.path.join(st.session_state.dir_home,'demo','demo_images'), file)
except:
file_path = save_uploaded_file_local(os.path.join(st.session_state.dir_home,'demo','demo_images'),os.path.join(st.session_state.dir_home,'demo','demo_images'), file)
st.session_state['input_list'].append(file_path)
img = Image.open(file_path)
img.thumbnail((GALLERY_IMAGE_SIZE, GALLERY_IMAGE_SIZE), Image.Resampling.LANCZOS)
try:
file_path_small = save_uploaded_file(st.session_state['dir_uploaded_images_small'], file, img)
except:
file_path_small = save_uploaded_file_local(st.session_state['dir_uploaded_images_small'],st.session_state['dir_uploaded_images_small'], file, img)
st.session_state['input_list_small'].append(file_path_small)
def refresh():
st.session_state['uploader_idk'] += 1
st.write('')
# def display_image_gallery():
# # Initialize the container
# con_image = st.empty()
# # Start the div for the image grid
# img_grid_html = """
#
# """
# # Loop through each image in the input list
# # with con_image.container():
# for image_path in st.session_state['input_list']:
# # Open the image and create a thumbnail
# img = Image.open(image_path)
# img.thumbnail((120, 120), Image.Resampling.LANCZOS)
# # Convert the image to base64
# base64_image = image_to_base64(img)
# # Append the image to the grid HTML
# # img_html = f"""
# #
# #
![Image](data:image/jpeg;base64,{base64_image})
# #
# # """
# img_html = f"""
#
![Image](data:image/jpeg;base64,{base64_image})
# """
# img_grid_html += img_html
# # st.markdown(img_html, unsafe_allow_html=True)
# # Close the div for the image grid
# img_grid_html += "
"
# # Display the image grid in the container
# with con_image.container():
# st.markdown(img_grid_html, unsafe_allow_html=True)
# # The CSS to make the images display inline and be responsive
# css = """
#
# """
# # Apply the CSS
# st.markdown(css, unsafe_allow_html=True)
########################################################################################################
########################################################################################################
########################################################################################################
class ProgressReport:
def __init__(self, overall_bar, batch_bar, text_overall, text_batch):
self.overall_bar = overall_bar
self.batch_bar = batch_bar
self.text_overall = text_overall
self.text_batch = text_batch
self.current_overall_step = 0
self.total_overall_steps = 20 # number of major steps in machine function
self.current_batch = 0
self.total_batches = 20
def update_overall(self, step_name=""):
self.current_overall_step += 1
self.overall_bar.progress(self.current_overall_step / self.total_overall_steps)
self.text_overall.text(step_name)
def update_batch(self, step_name=""):
self.current_batch += 1
self.batch_bar.progress(self.current_batch / self.total_batches)
self.text_batch.text(step_name)
def set_n_batches(self, n_batches):
self.total_batches = n_batches
def set_n_overall(self, total_overall_steps):
self.current_overall_step = 0
self.overall_bar.progress(0)
self.total_overall_steps = total_overall_steps
def reset_batch(self, step_name):
self.current_batch = 0
self.batch_bar.progress(0)
self.text_batch.text(step_name)
def reset_overall(self, step_name):
self.current_overall_step = 0
self.overall_bar.progress(0)
self.text_overall.text(step_name)
def get_n_images(self):
return self.n_images
def get_n_overall(self):
return self.total_overall_steps
class JSONReport:
def __init__(self, col_updates, col_json, col_json_WFO, col_json_GEO, col_json_map):
self.plant_list = [':evergreen_tree:', ':deciduous_tree:',':palm_tree:',
':maple_leaf:',':fallen_leaf:',':mushroom:',':leaves:',
':cactus:',':seedling:',':tulip:',':sunflower:',':hibiscus:',
':cherry_blossom:',':rose:',]
self.location_list = [':earth_africa:',':earth_americas:',':earth_asia:',]
self.book_list = [':bookmark_tabs:',':ledger:',':notebook:',':clipboard:',':scroll:',
':notebook_with_decorative_cover:',':green_book:',':blue_book:',
':open_book:',':closed_book:',':book:',
':orange_book:',':books:',':memo:',':pencil:',
]
# Create placeholders for each JSON component
self.col_updates = col_updates
self.col_json = col_json
self.col_json_WFO = col_json_WFO
self.col_json_GEO = col_json_GEO
self.col_json_map = col_json_map
self.update_main = col_updates.empty()
self.update_left = col_json.empty()
self.header_json = col_json.empty()
self.json_placeholder = col_json.empty()
self.update_middle = col_json_WFO.empty()
self.header_json_WFO = col_json_WFO.empty()
self.json_WFO_placeholder = col_json_WFO.empty()
self.update_right = col_json_GEO.empty()
self.header_json_GEO = col_json_GEO.empty()
self.json_GEO_placeholder = col_json_GEO.empty()
self.update_map = col_json_map.empty()
self.header_json_map = col_json_map.empty()
self.json_map = col_json_map.empty()
self.json = None
self.json_WFO = None
self.json_GEO = None
self.text_main = ''
self.text_middle = ''
self.text_right = ''
self.header_text_main = None
self.header_text_middle = None
self.header_text_right = None
def set_JSON(self, json_main, json_WFO, json_GEO):
i_plant = random.randint(0,len(self.plant_list)-1)
i_location = random.randint(0,len(self.location_list)-1)
i_book = random.randint(0,len(self.book_list)-1)
self.json = json_main
self.json_WFO = json_WFO
self.json_GEO = json_GEO
# Update placeholders with new JSON data
self.header_text_main = None
self.header_text_middle = None
self.header_text_right = None
self.update_main.subheader(f':loudspeaker: {self.text_main}')
self.update_left.subheader(f'{self.book_list[i_book]}', divider='rainbow')
self.update_middle.subheader(f'{self.plant_list[i_plant]}', divider='rainbow')
self.update_right.subheader(f'{self.location_list[i_location]}', divider='rainbow')
self.update_map.subheader(f':world_map:', divider='rainbow')
self.header_json.markdown('**LLM-derived information from the OCR text**')
self.header_json_WFO.markdown('World Flora Online')
self.header_json_GEO.markdown('Geolocate')
self.header_json_map.markdown(f':large_purple_circle: :violet[Geolocated] :large_green_circle: :green[From OCR Text]')
self.json_placeholder.json(self.json)
self.json_WFO_placeholder.json(self.json_WFO)
self.json_GEO_placeholder.json(self.json_GEO)
# If GEO data is available, plot on the map
# Clear the existing content in the map placeholder
# Clear the existing content in the map placeholder
self.json_map.empty()
map_points = []
map_data = []
# Function to safely convert to float
def safe_float_convert(value):
try:
return float(value)
except (ValueError, TypeError):
return None
# Check and process first point's data
lat = safe_float_convert(self.json_GEO.get("GEO_decimal_lat")) if self.json_GEO else None
lon = safe_float_convert(self.json_GEO.get("GEO_decimal_long")) if self.json_GEO else None
if lat is not None and lon is not None:
map_points.append({'lat': lat, 'lon': lon, 'color': '#8800ff' , 'size': [50000]})
# Check and process second point's data
lat_verbatim = safe_float_convert(self.json.get("decimalLatitude")) if self.json else None
lon_verbatim = safe_float_convert(self.json.get("decimalLongitude")) if self.json else None
if lat_verbatim is not None and lon_verbatim is not None:
map_points.append({'lat': lat_verbatim, 'lon': lon_verbatim, 'color': '#00c227' , 'size': [25000]})
# Convert the list of points to a DataFrame
map_data = pd.DataFrame(map_points)
# Display the map if map_data is not empty
if not map_data.empty:
with self.json_map:
st.map(map_data, zoom=4, size='size', color='color', use_container_width=True)
def set_text(self, text_main=None, text_middle=None, text_right=None):
if text_main:
self.text_main = text_main
self.update_main.subheader(f':loudspeaker: {self.text_main}')
if text_middle:
self.text_middle = text_middle
self.update_middle.subheader('', divider='rainbow')
if text_right:
self.text_right = text_right
self.update_right.subheader(self.text_right, divider='rainbow')
def clear_JSON(self):
self.json = None
self.json_WFO = None
self.json_GEO = None
# Clear the content in the placeholders
self.json_placeholder.empty()
self.json_WFO_placeholder.empty()
self.json_GEO_placeholder.empty()
def format_json(self, json_obj):
try:
return json.dumps(json.loads(json_obj), indent=4, sort_keys=False)
except:
return json.dumps(json_obj, indent=4, sort_keys=False)
def setup_streamlit_config(dir_home):
# Define the directory path and filename
dir_path = os.path.join(dir_home, ".streamlit")
file_path = os.path.join(dir_path, "config.toml")
# Check if directory exists, if not create it
if not os.path.exists(dir_path):
os.makedirs(dir_path)
# Create or modify the file with the provided content
config_content = f"""
[theme]
base = "dark"
primaryColor = "#00ff00"
[server]
enableStaticServing = false
runOnSave = true
port = 8524
"""
with open(file_path, "w") as f:
f.write(config_content.strip())
def display_scrollable_results(JSON_results, test_results, OPT2, OPT3):
"""
Display the results from JSON_results in a scrollable container.
"""
# Initialize the container
con_results = st.empty()
with con_results.container():
# Start the custom container for all the results
results_html = """"""
# The CSS to make this container scrollable
css = """
"""
# Apply the CSS and then the results
st.markdown(css, unsafe_allow_html=True)
st.markdown(results_html, unsafe_allow_html=True)
def display_test_results(test_results, JSON_results, llm_version):
if llm_version == 'gpt':
OPT1, OPT2, OPT3 = TestOptionsGPT.get_options()
elif llm_version == 'palm':
OPT1, OPT2, OPT3 = TestOptionsPalm.get_options()
else:
raise
widths = [1] * (len(OPT1) + 2) + [2]
columns = st.columns(widths)
with columns[0]:
st.write("LeafMachine2")
with columns[1]:
st.write("Prompt")
with columns[len(OPT1) + 2]:
st.write("Scroll to See Last Transcription in Each Test")
already_written = set()
for test_name, result in sorted(test_results.items()):
_, ind_opt1, _, _ = test_name.split('__')
option_value = OPT1[int(ind_opt1.split('-')[1])]
if option_value not in already_written:
with columns[int(ind_opt1.split('-')[1]) + 2]:
st.write(option_value)
already_written.add(option_value)
printed_options = set()
with columns[-1]:
display_scrollable_results(JSON_results, test_results, OPT2, OPT3)
# Close the custom container
st.write('', unsafe_allow_html=True)
for idx, (test_name, result) in enumerate(sorted(test_results.items())):
_, ind_opt1, ind_opt2, ind_opt3 = test_name.split('__')
opt2_readable = "Use LeafMachine2" if OPT2[int(ind_opt2.split('-')[1])] else "Don't use LeafMachine2"
opt3_readable = f"{OPT3[int(ind_opt3.split('-')[1])]}"
if (opt2_readable, opt3_readable) not in printed_options:
with columns[0]:
st.info(f"{opt2_readable}")
st.write('---')
with columns[1]:
st.info(f"{opt3_readable}")
st.write('---')
printed_options.add((opt2_readable, opt3_readable))
with columns[int(ind_opt1.split('-')[1]) + 2]:
if result:
st.success(f"Test Passed")
else:
st.error(f"Test Failed")
st.write('---')
# success_count = sum(1 for result in test_results.values() if result)
# failure_count = len(test_results) - success_count
# proportional_rain("🥇", success_count, "💔", failure_count, font_size=72, falling_speed=5, animation_length="infinite")
# rain_emojis(test_results)
def add_emoji_delay():
time.sleep(0.3)
# def rain_emojis(test_results):
# # test_results = {
# # 'test1': True, # Test passed
# # 'test2': True, # Test passed
# # 'test3': True, # Test passed
# # 'test4': False, # Test failed
# # 'test5': False, # Test failed
# # 'test6': False, # Test failed
# # 'test7': False, # Test failed
# # 'test8': False, # Test failed
# # 'test9': False, # Test failed
# # 'test10': False, # Test failed
# # }
# success_emojis = ["🥇", "🏆", "🍾", "🙌"]
# failure_emojis = ["💔", "😭"]
# success_count = sum(1 for result in test_results.values() if result)
# failure_count = len(test_results) - success_count
# chosen_emoji = random.choice(success_emojis)
# for _ in range(success_count):
# rain(
# emoji=chosen_emoji,
# font_size=72,
# falling_speed=4,
# animation_length=2,
# )
# add_emoji_delay()
# chosen_emoji = random.choice(failure_emojis)
# for _ in range(failure_count):
# rain(
# emoji=chosen_emoji,
# font_size=72,
# falling_speed=5,
# animation_length=1,
# )
# add_emoji_delay()
def format_json(json_obj):
try:
return json.dumps(json.loads(json_obj), indent=4, sort_keys=False)
except:
return json.dumps(json_obj, indent=4, sort_keys=False)
def get_prompt_versions(LLM_version):
yaml_files = [f for f in os.listdir(os.path.join(st.session_state.dir_home, 'custom_prompts')) if f.endswith('.yaml')]
return yaml_files
def get_private_file():
dir_home = os.path.dirname(__file__)
path_cfg_private = os.path.join(dir_home, 'PRIVATE_DATA.yaml')
return get_cfg_from_full_path(path_cfg_private)
def blog_text_and_image(text=None, fullpath=None, width=700):
if text:
st.markdown(f"{text}")
if fullpath:
st.session_state.logo = Image.open(fullpath)
st.image(st.session_state.logo, width=width)
def blog_text(text_bold, text):
st.markdown(f"- **{text_bold}**{text}")
def blog_text_plain(text_bold, text):
st.markdown(f"**{text_bold}** {text}")
def create_private_file():
section_left = 2
section_mid = 6
section_right = 2
st.session_state.proceed_to_main = False
st.title("VoucherVision")
_, col_private,__= st.columns([section_left,section_mid, section_right])
if st.session_state.private_file:
cfg_private = get_private_file()
else:
cfg_private = {}
cfg_private['openai'] = {}
cfg_private['openai']['OPENAI_API_KEY'] =''
cfg_private['openai_azure'] = {}
cfg_private['openai_azure']['OPENAI_API_KEY_AZURE'] = ''
cfg_private['openai_azure']['OPENAI_API_VERSION'] = ''
cfg_private['openai_azure']['OPENAI_API_BASE'] =''
cfg_private['openai_azure']['OPENAI_ORGANIZATION'] =''
cfg_private['openai_azure']['OPENAI_API_TYPE'] =''
cfg_private['google'] = {}
cfg_private['google']['GOOGLE_APPLICATION_CREDENTIALS'] =''
cfg_private['google']['GOOGLE_PALM_API'] =''
cfg_private['google']['GOOGLE_PROJECT_ID'] =''
cfg_private['google']['GOOGLE_LOCATION'] =''
cfg_private['mistral'] = {}
cfg_private['mistral']['MISTRAL_API_KEY'] =''
cfg_private['here'] = {}
cfg_private['here']['APP_ID'] =''
cfg_private['here']['API_KEY'] =''
cfg_private['open_cage_geocode'] = {}
cfg_private['open_cage_geocode']['API_KEY'] =''
with col_private:
st.header("Set API keys")
st.warning("To commit changes to API keys you must press the 'Set API Keys' button at the bottom of the page.")
st.write("Before using VoucherVision you must set your API keys. All keys are stored locally on your computer and are never made public.")
st.write("API keys are stored in `../VoucherVision/PRIVATE_DATA.yaml`.")
st.write("Deleting this file will allow you to reset API keys. Alternatively, you can edit the keys in the user interface or by manually editing the `.yaml` file in a text editor.")
st.write("Leave keys blank if you do not intend to use that service.")
st.info("Note: You can manually edit these API keys later by opening the /PRIVATE_DATA.yaml file in a plain text editor.")
st.write("---")
st.subheader("Google Vision (*Required*) / Google PaLM 2 / Google Gemini")
st.markdown("VoucherVision currently uses [Google Vision API](https://cloud.google.com/vision/docs/ocr) for OCR. Generating an API key for this is more involved than the others. [Please carefully follow the instructions outlined here to create and setup your account.](https://cloud.google.com/vision/docs/setup) ")
st.markdown("""Once your account is created, [visit this page](https://console.cloud.google.com) and create a project. Then follow these instructions:""")
with st.expander("**View Google API Instructions**"):
blog_text_and_image(text="Select your project, then in the search bar, search for `vertex ai` and select the option in the photo below.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_00.PNG'))
blog_text_and_image(text="On the main overview page, click `Enable All Recommended APIs`. Sometimes this button may be hidden. In that case, enable all of the suggested APIs listed on this page.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_0.PNG'))
blog_text_and_image(text="Sometimes this button may be hidden. In that case, enable all of the suggested APIs listed on this page.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_2.PNG'))
blog_text_and_image(text="Make sure that all APIs are enabled.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_1.PNG'))
blog_text_and_image(text="Find the `Vision AI API` service and go to its page.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_3.PNG'))
blog_text_and_image(text="Find the `Vision AI API` service and go to its page. This is the API service required to use OCR in VoucherVision and must be enabled.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_6.PNG'))
blog_text_and_image(text="You can also search for the Vertex AI Vision service.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_4.PNG'))
blog_text_and_image(text=None,
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_5.PNG'))
st.subheader("Getting a Google JSON authentication key")
st.write("Google uses a JSON file to store additional authentication information. Save this file in a safe, private location and assign the `GOOGLE_APPLICATION_CREDENTIALS` value to the file path. For Hugging Face, copy the contents of the JSON file including the `\{\}` and paste it as the secret value.")
st.write("To download your JSON key...")
blog_text_and_image(text="Open the navigation menu. Click on the hamburger menu (three horizontal lines) in the top left corner. Go to IAM & Admin. ",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_7.PNG'),width=300)
blog_text_and_image(text="In the navigation pane, hover over `IAM & Admin` and then click on `Service accounts`.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_8.PNG'))
blog_text_and_image(text="Find the default Compute Engine service account, select it.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_9.PNG'))
blog_text_and_image(text="Click `Add Key`.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_10.PNG'))
blog_text_and_image(text="Select `JSON` and click create. This will download your key. Store this in a safe location. The file path to this safe location is the value that you enter into the `GOOGLE_APPLICATION_CREDENTIALS` value.",
fullpath=os.path.join(st.session_state.dir_home, 'demo','google','google_api_11.PNG'))
blog_text(text_bold="Store Safely", text=": This file contains sensitive data that can be used to authenticate and bill your Google Cloud account. Never commit it to public repositories or expose it in any way. Always keep it safe and secure.")
st.write("Below is an example of the JSON key.")
st.json({
"type": "service_account",
"project_id": "NAME OF YOUR PROJECT",
"private_key_id": "XXXXXXXXXXXXXXXXXXXXXXXX",
"private_key": "-----BEGIN PRIVATE KEY-----\naaaaaaaaaaa\n-----END PRIVATE KEY-----\n",
"client_email": "EMAIL-ADDRESS@developer.gserviceaccount.com",
"client_id": "ID NUMBER",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "A LONG URL",
"universe_domain": "googleapis.com"
})
blog_text('Google project ID', ': The project ID is the "project_id" value from the JSON file.')
blog_text('Google project location', ': The project location specifies the location of the Google server that your project resources will utilize. It should not really make a difference which location you choose. We use `us-central1`, but you might want to choose a location closer to where you live. [please see this page for a list of available regions](https://cloud.google.com/vertex-ai/docs/general/locations)')
google_application_credentials = st.text_input(label = 'Full path to Google Cloud JSON API key file', value = cfg_private['google'].get('GOOGLE_APPLICATION_CREDENTIALS', ''),
placeholder = 'e.g. C:/Documents/Secret_Files/google_API/application_default_credentials.json',
help ="This API Key is in the form of a JSON file. Please save the JSON file in a safe directory. DO NOT store the JSON key inside of the VoucherVision directory.",
type='password')
google_project_location = st.text_input(label = 'Google project location', value = cfg_private['google'].get('GOOGLE_LOCATION', ''),
placeholder = 'e.g. us-central1',
help ="This is the location of where your Google services are operating.",
type='password')
google_project_id = st.text_input(label = 'Google project ID', value = cfg_private['google'].get('GOOGLE_PROJECT_ID', ''),
placeholder = 'e.g. my-project-name',
help ="This is the value in the `project_id` field in your JSON key.",
type='password')
st.write("---")
st.subheader("OpenAI")
st.markdown("API key for first-party OpenAI API. Create an account with OpenAI [here](https://platform.openai.com/signup), then create an API key [here](https://platform.openai.com/account/api-keys).")
openai_api_key = st.text_input("openai_api_key", cfg_private['openai'].get('OPENAI_API_KEY', ''),
help='The actual API key. Likely to be a string of 2 character, a dash, and then a 48-character string: sk-XXXXXXXX...',
placeholder = 'e.g. sk-XXXXXXXX...',
type='password')
st.write("---")
st.subheader("OpenAI - Azure")
st.markdown("This version OpenAI relies on Azure servers directly as is intended for private enterprise instances of OpenAI's services, such as [UM-GPT](https://its.umich.edu/computing/ai). Administrators will provide you with the following information.")
azure_openai_api_version = st.text_input("OPENAI_API_VERSION", cfg_private['openai_azure'].get('OPENAI_API_VERSION', ''),
help='API Version e.g. "2023-05-15"',
placeholder = 'e.g. 2023-05-15',
type='password')
azure_openai_api_key = st.text_input("OPENAI_API_KEY_AZURE", cfg_private['openai_azure'].get('OPENAI_API_KEY_AZURE', ''),
help='The actual API key. Likely to be a 32-character string. This might also be called "endpoint."',
placeholder = 'e.g. 12333333333333333333333333333332',
type='password')
azure_openai_api_base = st.text_input("OPENAI_API_BASE", cfg_private['openai_azure'].get('OPENAI_API_BASE', ''),
help='The base url for the API e.g. "https://api.umgpt.umich.edu/azure-openai-api"',
placeholder = 'e.g. https://api.umgpt.umich.edu/azure-openai-api',
type='password')
azure_openai_organization = st.text_input("OPENAI_ORGANIZATION", cfg_private['openai_azure'].get('OPENAI_ORGANIZATION', ''),
help='Your organization code. Likely a short string.',
placeholder = 'e.g. 123456',
type='password')
azure_openai_api_type = st.text_input("OPENAI_API_TYPE", cfg_private['openai_azure'].get('OPENAI_API_TYPE', ''),
help='The API type. Typically "azure"',
placeholder = 'e.g. azure',
type='password')
# st.write("---")
# st.subheader("Google PaLM 2 (Deprecated)")
# st.write("Plea")
# st.markdown('Follow these [instructions](https://developers.generativeai.google/tutorials/setup) to generate an API key for PaLM 2. You may need to also activate an account with [MakerSuite](https://makersuite.google.com/app/apikey) and enable "early access." If this is deprecated, then use the full Google API instructions above.')
# google_palm = st.text_input("Google PaLM 2 API Key", cfg_private['google'].get('GOOGLE_PALM_API', ''),
# help='The MakerSuite API key e.g. a 32-character string',
# placeholder='e.g. SATgthsykuE64FgrrrrEervr3S4455t_geyDeGq',
# type='password')
st.write("---")
st.subheader("MistralAI")
st.markdown('Follow these [instructions](https://console.mistral.ai/) to generate an API key for MistralAI.')
mistral_API_KEY = st.text_input("MistralAI API Key", cfg_private['mistral'].get('MISTRAL_API_KEY', ''),
help='e.g. a 32-character string',
placeholder='e.g. SATgthsykuE64FgrrrrEervr3S4455t_geyDeGq',
type='password')
st.write("---")
st.subheader("HERE Geocoding")
st.markdown('Follow these [instructions](https://platform.here.com/sign-up?step=verify-identity) to generate an API key for HERE.')
here_APP_ID = st.text_input("HERE Geocoding App ID", cfg_private['here'].get('APP_ID', ''),
help='e.g. a 32-character string',
placeholder='e.g. SATgthsykuE64FgrrrrEervr3S4455t_geyDeGq',
type='password')
here_API_KEY = st.text_input("HERE Geocoding API Key", cfg_private['here'].get('API_KEY', ''),
help='e.g. a 32-character string',
placeholder='e.g. SATgthsykuE64FgrrrrEervr3S4455t_geyDeGq',
type='password')
st.button("Set API Keys",type='primary', on_click=save_changes_to_API_keys,
args=[cfg_private,
openai_api_key,
azure_openai_api_version, azure_openai_api_key, azure_openai_api_base, azure_openai_organization, azure_openai_api_type,
google_application_credentials, google_project_location, google_project_id,
mistral_API_KEY,
here_APP_ID, here_API_KEY])
if st.button('Proceed to VoucherVision'):
st.session_state.private_file = does_private_file_exist()
st.session_state.proceed_to_private = False
st.session_state.proceed_to_main = True
st.rerun()
def save_changes_to_API_keys(cfg_private,
openai_api_key,
azure_openai_api_version, azure_openai_api_key, azure_openai_api_base, azure_openai_organization, azure_openai_api_type,
google_application_credentials, google_project_location, google_project_id,
mistral_API_KEY,
here_APP_ID, here_API_KEY):
# Update the configuration dictionary with the new values
cfg_private['openai']['OPENAI_API_KEY'] = openai_api_key
cfg_private['openai_azure']['OPENAI_API_VERSION'] = azure_openai_api_version
cfg_private['openai_azure']['OPENAI_API_KEY_AZURE'] = azure_openai_api_key
cfg_private['openai_azure']['OPENAI_API_BASE'] = azure_openai_api_base
cfg_private['openai_azure']['OPENAI_ORGANIZATION'] = azure_openai_organization
cfg_private['openai_azure']['OPENAI_API_TYPE'] = azure_openai_api_type
cfg_private['google']['GOOGLE_APPLICATION_CREDENTIALS'] = google_application_credentials
cfg_private['google']['GOOGLE_PROJECT_ID'] = google_project_id
cfg_private['google']['GOOGLE_LOCATION'] = google_project_location
cfg_private['mistral']['MISTRAL_API_KEY'] = mistral_API_KEY
cfg_private['here']['APP_ID'] = here_APP_ID
cfg_private['here']['API_KEY'] = here_API_KEY
# Call the function to write the updated configuration to the YAML file
write_config_file(cfg_private, st.session_state.dir_home, filename="PRIVATE_DATA.yaml")
st.success(f"API Keys saved to {os.path.join(st.session_state.dir_home, 'PRIVATE_DATA.yaml')}")
# st.session_state.private_file = does_private_file_exist()
# Function to load a YAML file and update session_state
### Updated to match HF version
# def save_prompt_yaml(filename):
@st.cache_data
def show_header_welcome():
st.session_state.logo_path = os.path.join(st.session_state.dir_home, 'img','logo.png')
st.session_state.logo = Image.open(st.session_state.logo_path)
st.image(st.session_state.logo, width=250)
def determine_n_images():
try:
# Check if 'dir_uploaded_images' key exists in session state and it is not empty
if 'dir_uploaded_images' in st.session_state and st.session_state['dir_uploaded_images']:
dir_path = st.session_state['dir_uploaded_images'] # This would be the path to the directory
# Count only files (not directories) in the specified directory
count = len([f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))])
return count
else:
return None # Return 0 if the directory path doesn't exist or is empty
except Exception as e:
print(e)
return None
# def determine_n_images():
# try:
# # Check if 'dir_uploaded_images' key exists and it is not empty
# if 'dir_uploaded_images' in st and st['dir_uploaded_images']:
# dir_path = st['dir_uploaded_images'] # This would be the path to the directory
# return len([f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))])
# else:
# return None
# except:
# return None
def save_api_status(present_keys, missing_keys, date_of_check):
with open(os.path.join(st.session_state.dir_home,'api_status.yaml'), 'w') as file:
yaml.dump({'present_keys': present_keys, 'missing_keys': missing_keys, "date": date_of_check}, file)
def load_api_status():
try:
with open(os.path.join(st.session_state.dir_home,'api_status.yaml'), 'r') as file:
status = yaml.safe_load(file)
return status.get('present_keys', []), status.get('missing_keys', []), status.get('date', [])
except FileNotFoundError:
return None, None, None
def display_api_key_status(ccol):
if not st.session_state['API_checked']:
present_keys, missing_keys, date_of_check = load_api_status()
if present_keys is None and missing_keys is None:
st.session_state['API_checked'] = False
else:
# Convert keys to annotations (similar to what you do in check_api_key_status)
present_annotations = []
missing_annotations = []
for key in present_keys:
if "Valid" in key:
show_text = key.split('(')[0]
present_annotations.append((show_text, "ready!", "#059c1b")) # Green for valid
elif "Invalid" in key:
show_text = key.split('(')[0]
present_annotations.append((show_text, "error", "#870307")) # Red for invalid
st.session_state['present_annotations'] = present_annotations
st.session_state['missing_annotations'] = missing_annotations
st.session_state['date_of_check'] = date_of_check
st.session_state['API_checked'] = True
# print('for')
# print(st.session_state['present_annotations'])
# print(st.session_state['missing_annotations'])
else:
# print('else')
# print(st.session_state['present_annotations'])
# print(st.session_state['missing_annotations'])
pass
# Check if the API status has already been retrieved
if 'API_checked' not in st.session_state or not st.session_state['API_checked'] or st.session_state['API_rechecked']:
with ccol:
with st.spinner('Verifying APIs by sending short requests...'):
check_api_key_status()
st.session_state['API_checked'] = True
st.session_state['API_rechecked'] = False
st.markdown(f"Last checked on {st.session_state['date_of_check']}")
# Display present keys horizontally
if 'present_annotations' in st.session_state and st.session_state['present_annotations']:
annotated_text(*st.session_state['present_annotations'])
# Display missing keys horizontally
if 'missing_annotations' in st.session_state and st.session_state['missing_annotations']:
annotated_text(*st.session_state['missing_annotations'])
def check_api_key_status():
try:
path_cfg_private = os.path.join(st.session_state.dir_home, 'PRIVATE_DATA.yaml')
cfg_private = get_cfg_from_full_path(path_cfg_private)
except:
cfg_private = None
API_Validator = APIvalidation(cfg_private, st.session_state.dir_home, st.session_state['is_hf'])
present_keys, missing_keys, date_of_check = API_Validator.report_api_key_status() # Assuming this function returns two lists
# Prepare annotations for present keys
present_annotations = []
missing_annotations = []
for key in present_keys:
if "Valid" in key:
show_text = key.split('(')[0]
present_annotations.append((show_text, "ready!", "#059c1b")) # Green for valid
elif "Invalid" in key:
show_text = key.split('(')[0]
present_annotations.append((show_text, "error", "#870307")) # Red for invalid
# Prepare annotations for missing keys
for key in missing_keys:
show_text = key.split('(')[0]
missing_annotations.append((show_text, "n/a", " ", "#c4c4c4")) # Red for invalid
# Save API key status
save_api_status(present_keys, missing_keys, date_of_check)
st.session_state['present_annotations'] = present_annotations
st.session_state['missing_annotations'] = missing_annotations
st.session_state['date_of_check'] = date_of_check
def convert_cost_dict_to_table(cost, name):
# Convert the dictionary to a pandas DataFrame for nicer display
df = pd.DataFrame.from_dict(cost, orient='index')
df.reset_index(inplace=True)
df.columns = [str(name), 'Input', 'Output']
# Apply color gradient
cm = sns.light_palette("green", as_cmap=True)
styled_df = df.style.background_gradient(cmap=cm, subset=['Input', 'Output'])
return styled_df
def get_all_cost_tables():
warnings.filterwarnings('ignore', message=".*is_sparse is deprecated.*")
CostMap = ModelMaps
cost_names = CostMap.get_all_mapping_cost()
path_api_cost = os.path.join(st.session_state.dir_home,'api_cost','api_cost.yaml')
with open(path_api_cost, 'r') as file:
cost_data = yaml.safe_load(file)
cost_openai = {}
cost_azure = {}
cost_google = {}
cost_mistral = {}
cost_local = {}
for key, value in cost_names.items():
parts = value.split("_")
if 'LOCAL' in parts:
cost_local[key] = cost_data.get(value,'')
elif 'AZURE' in parts:
cost_azure[key] = cost_data.get(value,'')
elif 'GPT' in parts:
cost_openai[key] = cost_data.get(value,'')
elif 'PALM2' in parts or 'GEMINI' in parts:
cost_google[key] = cost_data.get(value,'')
elif ('MISTRAL' in parts) or ('MIXTRAL' in parts):
cost_mistral[key] = cost_data.get(value,'')
styled_cost_openai = convert_cost_dict_to_table(cost_openai, "OpenAI")
styled_cost_azure = convert_cost_dict_to_table(cost_azure, "OpenAI (Azure Endpoints)")
styled_cost_google = convert_cost_dict_to_table(cost_google, "Google (VertexAI)")
styled_cost_mistral = convert_cost_dict_to_table(cost_mistral, "MistralAI")
styled_cost_local = convert_cost_dict_to_table(cost_local, "Local Models")
return cost_openai, styled_cost_openai, cost_azure, styled_cost_azure, cost_google, styled_cost_google, cost_mistral, styled_cost_mistral, cost_local, styled_cost_local
def content_header():
col_logo, col_run_1, col_run_2, col_run_3, col_run_4 = st.columns([2,2,2,2,4])
with col_run_4:
with st.expander("View Messages and Updates"):
st.info("***Note:*** If you use VoucherVision frequently, you can change the default values that are auto-populated in the form below. In a text editor or IDE, edit the first few rows in the file `../VoucherVision/vouchervision/VoucherVision_Config_Builder.py`")
st.info("Please enable LeafMachine2 collage for full-sized images of herbarium vouchers, you will get better results!")
col_test = st.container()
st.subheader("Overall Progress")
col_run_info_1 = st.columns([1])[0]
col_updates_1, col_updates_2 = st.columns([5,1])
col_json, col_json_WFO, col_json_GEO, col_json_map = st.columns([2, 2, 2, 2])
with col_run_info_1:
# Progress
overall_progress_bar = st.progress(0)
text_overall = st.empty() # Placeholder for current step name
st.subheader('Transcription Progress')
batch_progress_bar = st.progress(0)
text_batch = st.empty() # Placeholder for current step name
progress_report = ProgressReport(overall_progress_bar, batch_progress_bar, text_overall, text_batch)
st.session_state['hold_output'] = st.toggle('View Final Transcription')
with col_logo:
show_header_welcome()
with col_run_1:
N_STEPS = 6
if check_if_usable(is_hf=st.session_state['is_hf']):
# b_text = f"Start Processing {st.session_state['processing_add_on']} Images" if st.session_state['processing_add_on'] > 1 else f"Start Processing {st.session_state['processing_add_on']} Image"
# if st.session_state['processing_add_on'] == 0:
b_text = f"Start Transcription"
if st.button(b_text, type='primary',use_container_width=True):
st.session_state['formatted_json'] = {}
st.session_state['formatted_json_WFO'] = {}
st.session_state['formatted_json_GEO'] = {}
st.session_state['json_report'] = JSONReport(col_updates_1, col_json, col_json_WFO, col_json_GEO, col_json_map)
st.session_state['json_report'].set_JSON(st.session_state['formatted_json'], st.session_state['formatted_json_WFO'], st.session_state['formatted_json_GEO'])
# Define number of overall steps
progress_report.set_n_overall(N_STEPS)
progress_report.update_overall(f"Starting VoucherVision...")
# First, write the config file.
write_config_file(st.session_state.config, st.session_state.dir_home, filename="VoucherVision.yaml")
path_custom_prompts = os.path.join(st.session_state.dir_home,'custom_prompts',st.session_state.config['leafmachine']['project']['prompt_version'])
# Call the machine function.
total_cost = 0.00
n_failed_OCR = 0
n_failed_LLM_calls = 0
# try:
voucher_vision_output = voucher_vision(None,
st.session_state.dir_home,
path_custom_prompts,
None,
progress_report,
st.session_state['json_report'],
path_api_cost=os.path.join(st.session_state.dir_home,'api_cost','api_cost.yaml'),
is_hf = st.session_state['is_hf'],
is_real_run=True)
st.session_state['formatted_json'] = voucher_vision_output['last_JSON_response']
st.session_state['formatted_json_WFO'] = voucher_vision_output['final_WFO_record']
st.session_state['formatted_json_GEO'] = voucher_vision_output['final_GEO_record']
total_cost = voucher_vision_output['total_cost']
n_failed_OCR = voucher_vision_output['n_failed_OCR']
n_failed_LLM_calls = voucher_vision_output['n_failed_LLM_calls']
st.session_state['zip_filepath'] = voucher_vision_output['zip_filepath']
# st.balloons()
# except Exception as e:
# with col_run_4:
# st.error(f"Transcription failed. Error: {e}")
if n_failed_OCR > 0:
with col_run_4:
st.error(f"Caution:heavy_exclamation_mark: :loudspeaker: {n_failed_LLM_calls} images had a no extractable OCR text :eyes:")
if n_failed_LLM_calls > 0:
with col_run_4:
st.error(f"Caution:heavy_exclamation_mark: :loudspeaker: {n_failed_LLM_calls} images had a failed LLM API call :eyes:")
st.error(f"Make sure that you have access to the chosen LLM API model. Sometimes certain OpenAI accounts do not have access to all models, for example")
if total_cost:
with col_run_4:
st.success(f":money_with_wings: This run cost :heavy_dollar_sign:{total_cost:.4f}")
else:
with col_run_4:
st.info(f":money_with_wings: This run cost :heavy_dollar_sign:{total_cost:.4f}")
if st.session_state['zip_filepath']:
create_download_button(st.session_state['zip_filepath'], col_run_1,key=97863332)
else:
st.button("Start Transcription", type='primary', disabled=True)
with col_run_4:
st.error(":heavy_exclamation_mark: Required API keys not set. Please visit the 'API Keys' tab and set the Google Vision OCR API key and at least one LLM key.")
if st.session_state['formatted_json']:
if st.session_state['hold_output']:
st.session_state['json_report'].set_JSON(st.session_state['formatted_json'], st.session_state['formatted_json_WFO'], st.session_state['formatted_json_GEO'])
if st.session_state['zip_filepath']:
create_download_button(st.session_state['zip_filepath'], col_run_1,key=978633452)
with col_run_1:
ct_left, ct_right = st.columns([1,1])
with ct_left:
st.button("Refresh", on_click=refresh, use_container_width=True)
with ct_right:
try:
st.page_link(os.path.join("pages","faqs.py"), label="FAQs", icon="❔")
except:
st.page_link(os.path.join(os.path.dirname(__file__),"pages","faqs.py"), label="FAQs", icon="❔")
# with col_run_2:
# if st.button("Test GPT"):
# progress_report.set_n_overall(TestOptionsGPT.get_length())
# test_results, JSON_results = run_demo_tests_GPT(progress_report)
# with col_test:
# display_test_results(test_results, JSON_results, 'gpt')
# st.balloons()
# if st.button("Test PaLM2"):
# progress_report.set_n_overall(TestOptionsPalm.get_length())
# test_results, JSON_results = run_demo_tests_Palm(progress_report)
# with col_test:
# display_test_results(test_results, JSON_results, 'palm')
# st.balloons()
with col_run_2:
if st.button('Save Current Settings',use_container_width=True):
if st.session_state.settings_filename:
config_file_path = os.path.join(st.session_state.dir_home, 'settings', st.session_state['settings_filename'] + '.yaml')
with open(config_file_path, 'w') as file:
yaml.dump(st.session_state.config, file, default_flow_style=False)
with col_run_4:
st.success(f'Current settings saved to {config_file_path}')
else:
with col_run_4:
st.error('Missing settings file name. Settings not saved.')
# st.session_state.config
with col_run_3:
st.session_state['settings_filename'] = st.text_input('Setting File Name',placeholder="Settings fileame",label_visibility='collapsed',value=None)
with col_run_2:
if st.button('Load Settings',use_container_width=True):
if st.session_state['loaded_settings_filename']:
path_load_settings = os.path.join(st.session_state['dir_settings'],st.session_state['loaded_settings_filename'])
if os.path.exists(path_load_settings) and not None:
with open(path_load_settings, 'r') as file:
loaded_config = yaml.safe_load(file)
st.session_state.config, st.session_state.dir_home = build_VV_config(loaded_cfg=loaded_config)
with col_run_4:
st.success(f'Loaded settings from {path_load_settings}')
else:
st.error(f'Path to settings file does not exist: {path_load_settings}')
else:
with col_run_4:
st.warning(f'Filename not selected')
with col_run_3:
st.session_state['settings_choice_null'] = 'Select previous settings...'
st.session_state['dir_settings'] = os.path.join(st.session_state.dir_home, 'settings')
all_settings_files = [st.session_state['settings_choice_null']] + [f for f in os.listdir(st.session_state['dir_settings']) if f.endswith('.yaml')]
settings_choice = st.selectbox('Load Previous Settings', all_settings_files,label_visibility='collapsed')
if settings_choice != st.session_state['settings_choice_null']:
st.session_state['loaded_settings_filename'] = settings_choice
with col_run_2:
if st.button("Check GPU Status",use_container_width=True):
success, info = test_GPU()
if success:
st.balloons()
with col_run_4:
for message in info:
st.success(message)
else:
with col_run_4:
for message in info:
st.warning(message)
def content_project_settings(col):
### Project
with col:
st.header('Project Settings')
st.session_state.config['leafmachine']['project']['run_name'] = st.text_input("Run name", st.session_state.config['leafmachine']['project'].get('run_name', ''),key=63456)
if not st.session_state.is_hf:
st.session_state.config['leafmachine']['project']['dir_output'] = st.text_input("Output directory", st.session_state.config['leafmachine']['project'].get('dir_output', ''))
def content_tools():
st.write("---")
st.header('Validation Tools')
tool_WFO = st.session_state.config['leafmachine']['project']['tool_WFO']
st.session_state.config['leafmachine']['project']['tool_WFO'] = st.checkbox(label="Enable World Flora Online taxonomy verification",
help="",
value=tool_WFO)
tool_GEO = st.session_state.config['leafmachine']['project']['tool_GEO']
st.session_state.config['leafmachine']['project']['tool_GEO'] = st.checkbox(label="Enable HERE geolocation hints",
help="",
value=tool_GEO)
tool_wikipedia = st.session_state.config['leafmachine']['project']['tool_wikipedia']
st.session_state.config['leafmachine']['project']['tool_wikipedia'] = st.checkbox(label="Enable Wikipedia verification",
help="",
value=tool_wikipedia)
def content_llm_cost():
st.write("---")
st.header('LLM Cost Calculator')
# ( n_in/1000 * Input + n_out/1000 * Output ) * n_img = COST
calculator_1,calculator_2,calculator_3,calculator_4,calculator_5 = st.columns([1,1,1,1,1])
st.subheader('Cost Matrix')
st.markdown('The table shows the cost of each LLM API per 1,000 tokens. An average VoucherVision call uses 2,000 input tokens and receives 500 output tokens.')
col_cost_1, col_cost_2, col_cost_3, col_cost_4, col_cost_5 = st.columns([1,1,1,1,1])
# Load all cost tables if not already done
if 'all_llm_cost' not in st.session_state:
st.session_state['all_llm_cost'] = True
st.session_state['cost_openai'], st.session_state['styled_cost_openai'], st.session_state['cost_azure'], st.session_state['styled_cost_azure'], st.session_state['cost_google'], st.session_state['styled_cost_google'], st.session_state['cost_mistral'], st.session_state['styled_cost_mistral'], st.session_state['cost_local'], st.session_state['styled_cost_local'] = get_all_cost_tables()
with calculator_1:
# Combine all model names into a single list
model_names = []
for df in [st.session_state['cost_openai'], st.session_state['cost_azure'], st.session_state['cost_google'], st.session_state['cost_mistral'], st.session_state['cost_local']]:
for key in df.keys():
model_names.append(key)
# Create a dropdown for model selection
selected_model = st.selectbox("Select a model", options=model_names)
with calculator_2:
# Create input fields for n_in, n_out, n_img
n_in = st.number_input("Tokens In", min_value=0, value=2000, step=50)
with calculator_3:
n_out = st.number_input("Tokens Out", min_value=0, value=500, step=50)
with calculator_4:
n_img = st.number_input("Number of Images", min_value=0, value=1000, step=100)
# Function to find the model's Input and Output values
def find_model_values(model, all_dfs):
for df in all_dfs:
if model in df.keys():
return df[model]['in'], df[model]['out']
return None, None
@st.cache_data
def show_cost_matrix_1(rounding):
st.dataframe(st.session_state.styled_cost_openai.format(precision=rounding), hide_index=True,)
@st.cache_data
def show_cost_matrix_2(rounding):
st.dataframe(st.session_state.styled_cost_azure.format(precision=rounding), hide_index=True,)
@st.cache_data
def show_cost_matrix_3(rounding):
st.dataframe(st.session_state.styled_cost_google.format(precision=rounding), hide_index=True,)
@st.cache_data
def show_cost_matrix_4(rounding):
st.dataframe(st.session_state.styled_cost_mistral.format(precision=rounding), hide_index=True,)
@st.cache_data
def show_cost_matrix_5(rounding):
st.dataframe(st.session_state.styled_cost_local.format(precision=rounding), hide_index=True,)
input_value, output_value = find_model_values(selected_model,
[st.session_state['cost_openai'], st.session_state['cost_azure'], st.session_state['cost_google'], st.session_state['cost_mistral'], st.session_state['cost_local']])
if input_value is not None and output_value is not None:
cost = (n_in/1000 * input_value + n_out/1000 * output_value) * n_img
with calculator_5:
st.text_input("Total Cost", f"${round(cost,2)}") # selected_model
rounding = 4
with col_cost_1:
show_cost_matrix_1(rounding)
with col_cost_2:
show_cost_matrix_2(rounding)
with col_cost_3:
show_cost_matrix_3(rounding)
with col_cost_4:
show_cost_matrix_4(rounding)
with col_cost_5:
show_cost_matrix_5(rounding)
def content_prompt_and_llm_version():
st.header('Prompt Version')
col_prompt_1, col_prompt_2 = st.columns([4,2])
with col_prompt_1:
available_prompts = get_prompt_versions(st.session_state.config['leafmachine']['LLM_version'])
if available_prompts:
default_version = available_prompts[0] ######### Can be configured by user #################################################################
selected_version = st.session_state.config['leafmachine']['project'].get('prompt_version', default_version)
if selected_version not in available_prompts:
selected_version = default_version
st.session_state.config['leafmachine']['project']['prompt_version'] = st.selectbox("Prompt Version", available_prompts, index=available_prompts.index(selected_version),label_visibility='collapsed')
with col_prompt_2:
# if st.button("Build Custom LLM Prompt"):
try:
st.page_link(os.path.join("pages","prompt_builder.py"), label="Prompt Builder", icon="🚧")
except:
st.page_link(os.path.join(os.path.dirname(__file__),"pages","prompt_builder.py"), label="Prompt Builder", icon="🚧")
st.header('LLM Version')
col_llm_1, col_llm_2 = st.columns([4,2])
with col_llm_1:
GUI_MODEL_LIST = ModelMaps.get_models_gui_list()
st.session_state.config['leafmachine']['LLM_version'] = st.selectbox("LLM version", GUI_MODEL_LIST, index=GUI_MODEL_LIST.index(st.session_state.config['leafmachine'].get('LLM_version', ModelMaps.MODELS_GUI_DEFAULT)))
st.markdown("""
Based on preliminary results, the following models perform the best. We are currently running tests of all possible OCR + LLM + Prompt combinations to create recipes for different workflows.
- Any Mistral model e.g., `Mistral Large`
- `PaLM 2 text-bison@001`
- `GPT 4 Turbo 1106-preview`
- `GPT 3.5 Turbo`
- `LOCAL Mixtral 7Bx8 Instruct`
- `LOCAL Mixtral 7B Instruct`
Larger models (e.g., `GPT 4`, `GPT 4 32k`, `Gemini Pro`) do not necessarily perform better for these tasks. MistralAI models exceeded our expectations and perform extremely well. PaLM 2 text-bison@001 also seems to consistently out-perform Gemini Pro.
The `SLTPvA_short.yaml` prompt also seems to work better with smaller LLMs (e.g., Mistral Tiny). Alternatively, enable double OCR to help the LLM focus on the OCR text given a longer prompt.
Models `GPT 3.5 Turbo` and `GPT 4 Turbo 0125-preview` enable OpenAI's [JSON mode](https://platform.openai.com/docs/guides/text-generation/json-mode), which helps prevent JSON errors. All models implement Langchain JSON parsing too, so JSON errors are rare for most models.""")
def content_api_check():
# In your Streamlit layout
# Create two columns for the header and the button
col_llm_2a, col_llm_2b = st.columns([6, 2]) # Adjust the ratio as needed
# Place the header in the first column
with col_llm_2a:
st.header('Available APIs')
# Display API key status
display_api_key_status(col_llm_2a)
# Place the button in the second column, right-justified
# with col_llm_2b:
if st.button("Re-Check API Keys"):
st.session_state['API_checked'] = False
st.session_state['API_rechecked'] = True
st.rerun()
# with col_llm_2c:
if not st.session_state.is_hf:
if st.button("Edit API Keys"):
st.session_state.proceed_to_private = True
st.rerun()
def adjust_ocr_options_based_on_capability(capability_score):
llava_models_requirements = {
"liuhaotian/llava-v1.6-mistral-7b": {"full": 18, "4bit": 9},
"liuhaotian/llava-v1.6-34b": {"full": 70, "4bit": 25},
"liuhaotian/llava-v1.6-vicuna-13b": {"full": 33, "4bit": 15},
"liuhaotian/llava-v1.6-vicuna-7b": {"full": 20, "4bit": 10},
}
if capability_score == 'no_gpu':
return False
else:
capability_score_n = int(capability_score.split("_")[1].split("GB")[0])
supported_models = [model for model, reqs in llava_models_requirements.items()
if reqs["full"] <= capability_score_n or reqs["4bit"] <= capability_score_n]
# If no models are supported, disable the LLaVA option
if not supported_models:
# Assuming the LLaVA option is the last in your list
return False # Indicate LLaVA is not supported
return True # Indicate LLaVA is supported
def content_ocr_method():
st.write("---")
st.header('OCR Methods')
with st.expander("Read about available OCR methods"):
st.subheader("Overview")
st.markdown("""VoucherVision can use the `Google Vision API`, `CRAFT` text detection + `trOCR`, and all `LLaVA v1.6` models.
VoucherVision sends the OCR inside of the LLM prompt. We have found that sending multiple copies, or multiple version of
the OCR text to the LLM helps the LLM maintain focus on the OCR text -- our prompts are quite long and the OCR text is reletively short.
Below you can choose the OCR method/s. You can 'stack' all of the methods if you want, which may improve results because
different OCR methods have different strengths, giving the LLM more information to work with. Alternative.y, you can select a single method and
send 2 copies to the LLM by enabling that option below.""")
st.subheader("Google Vision API")
st.markdown("""`Google Vision API` provides several OCR methods. We use the `document_text_detection()` service, designed to handle dense text blocks.
The `Handwritten` option CAN also be used for printed and mixed labels, but it is also optimized for handwriting. `Handwritten` uses the Google Vision Beta service.
This is the recommended default OCR method. `Printed` uses the regular Google Vision service and works well for general use.
You can also supplement Google Vision OCR by enabling trOCR, which is optimized for handwriting. trOCR requires segmented word images, which is provided as part
of the Google Vision metadata. trOCR does not require a GPU, but it runs *much* faster with a GPU.""")
st.subheader("LLaVA")
st.markdown("""`LLaVA` can replace Google Vision APIs. It requires the use of LeafMachine2 collage, or images that are majority text. It may struggle with very
long texts. LLaVA models are multimodal, meaning that we can upload the image and the model will transcribe (and even parse) the text all at once. With VoucherVision, we
support 4 different LLaVA models of varying sizes, some are much more capable than others. These models tend to outperform all other OCR methods for handwriting.
LLaVA models are run locally and require powerful GPUs to implement. While LLaVA models are capable of handling both the OCR and text parsing tasks all in one step,
this option only uses LLaVA to transcribe all of the text in the image and still uses a separate LLM to parse text in to categories. """)
st.subheader("CRAFT + trOCR")
st.markdown("""This pairing can replace Google Vision APIs and is computationally lighter than LLaVA. `CRAFT` locates text, segments lines of text, and feeds the segmentations
to the `trOCR` transformer model. This pairing requires at least an 8 GB GPU. trOCR is a Microsoft model optimized for handwriting. The base model is not as accurate as
LLaVA or Google Vision, but if you have a trOCR-based model, let us know and we will add support.""")
c1, c2 = st.columns([4,4])
# Check if LLaVA models are supported based on capability score
llava_supported = adjust_ocr_options_based_on_capability(st.session_state.capability_score)
if llava_supported:
st.success("LLaVA models are supported on this computer")
else:
st.warning("LLaVA models are NOT supported on this computer. Requires a GPU with at least 12 GB of VRAM.")
demo_text_h = f"Google_OCR_Handwriting:\nHERBARIUM OF MARCUS W. LYON , JR . Tracaulon sagittatum Indiana : Porter Co. incal Springs edge wet subdunal woods 1927 TX 11 Ilowers pink UNIVERSITE HERBARIUM MICH University of Michigan Herbarium 1439649 copyright reserved PERSICARIA FEB 2 6 1965 cm "
demo_text_tr = f"trOCR:\nherbarium of marcus w. lyon jr. : : : tracaulon sagittatum indiana porter co. incal springs TX 11 Ilowers pink 1439649 copyright reserved D H U Q "
demo_text_p = f"Google_OCR_Printed:\nTracaulon sagittatum Indiana : Porter Co. incal Springs edge wet subdunal woods 1927 Ilowers pink 1439649 copyright reserved PERSICARIA FEB 2 6 1965 cm "
demo_text_b = demo_text_h + '\n' + demo_text_p
demo_text_trb = demo_text_h + '\n' + demo_text_p + '\n' + demo_text_tr
demo_text_trh = demo_text_h + '\n' + demo_text_tr
demo_text_trp = demo_text_p + '\n' + demo_text_tr
options = ["Google Vision Handwritten", "Google Vision Printed", "CRAFT + trOCR","LLaVA"]
options_llava = ["llava-v1.6-mistral-7b", "llava-v1.6-34b", "llava-v1.6-vicuna-13b", "llava-v1.6-vicuna-7b",]
options_llava_bit = ["full", "4bit",]
captions_llava = [
"Full Model: 18 GB VRAM, 4-bit: 9 GB VRAM",
"Full Model: 70 GB VRAM, 4-bit: 25 GB VRAM",
"Full Model: 33 GB VRAM, 4-bit: 15 GB VRAM",
"Full Model: 20 GB VRAM, 4-bit: 10 GB VRAM",
]
captions_llava_bit = ["Full Model","4-bit Quantization",]
# Get the current OCR option from session state
OCR_option = st.session_state.config['leafmachine']['project']['OCR_option']
OCR_option_llava = st.session_state.config['leafmachine']['project']['OCR_option_llava']
OCR_option_llava_bit = st.session_state.config['leafmachine']['project']['OCR_option_llava_bit']
double_OCR = st.session_state.config['leafmachine']['project']['double_OCR']
# Map the OCR option to the index in options list
# You need to define the mapping based on your application's logic
default_index = 0 # Default to 0 if option not found
default_index_llava = 0 # Default to 0 if option not found
default_index_llava_bit = 0
with c1:
st.subheader("API Methods (Google Vision)")
st.write("Using APIs for OCR allows VoucherVision to run on most computers.")
st.session_state.config['leafmachine']['project']['double_OCR'] = st.checkbox(label="Send 2 copies of the OCR to the LLM",
help="This can help the LLMs focus attention on the OCR and not get lost in the longer instruction text",
value=double_OCR)
# Create the radio button
# OCR_option_select = st.radio(
# "Select the OCR Method",
# options,
# index=default_index,
# help="",captions=captions,
# )
default_values = [options[default_index]]
OCR_option_select = st.multiselect(
"Select the OCR Method(s)",
options=options,
default=default_values,
help="Select one or more OCR methods."
)
# st.session_state.config['leafmachine']['project']['OCR_option'] = OCR_option_select
# Handling multiple selections (Example logic)
OCR_options = {
"Google Vision Handwritten": 'hand',
"Google Vision Printed": 'normal',
"CRAFT + trOCR": 'CRAFT',
"LLaVA": 'LLaVA',
}
# Map selected options to their corresponding internal representations
selected_OCR_options = [OCR_options[option] for option in OCR_option_select]
# Assuming you need to use these mapped values elsewhere in your application
st.session_state.config['leafmachine']['project']['OCR_option'] = selected_OCR_options
with c2:
st.subheader("Local Methods")
st.write("Local methods are free, but require a capable GPU. ")
st.write("Supplement Google Vision OCR with trOCR (handwriting OCR) using `microsoft/trocr-base-handwritten`. This option requires Google Vision API and a GPU.")
if 'CRAFT' in selected_OCR_options:
do_use_trOCR = st.checkbox("Enable trOCR", value=True, key="Enable trOCR1",disabled=True)#,disabled=st.session_state['lacks_GPU'])
else:
do_use_trOCR = st.checkbox("Enable trOCR", value=st.session_state.config['leafmachine']['project']['do_use_trOCR'],key="Enable trOCR2")#,disabled=st.session_state['lacks_GPU'])
st.session_state.config['leafmachine']['project']['do_use_trOCR'] = do_use_trOCR
if do_use_trOCR:
# st.session_state.config['leafmachine']['project']['trOCR_model_path'] = "microsoft/trocr-large-handwritten"
default_trOCR_model_path = st.session_state.config['leafmachine']['project']['trOCR_model_path']
user_input_trOCR_model_path = st.text_input("trOCR Hugging Face model path. MUST be a fine-tuned version of 'microsoft/trocr-base-handwritten' or 'microsoft/trocr-large-handwritten', or a microsoft trOCR model.", value=default_trOCR_model_path)
if st.session_state.config['leafmachine']['project']['trOCR_model_path'] != user_input_trOCR_model_path:
is_valid_mp = is_valid_huggingface_model_path(user_input_trOCR_model_path)
if not is_valid_mp:
st.error(f"The Hugging Face model path {user_input_trOCR_model_path} is not valid. Please revise.")
else:
st.session_state.config['leafmachine']['project']['trOCR_model_path'] = user_input_trOCR_model_path
if 'LLaVA' in selected_OCR_options:
OCR_option_llava = st.radio(
"Select the LLaVA version",
options_llava,
index=default_index_llava,
help="",captions=captions_llava,
)
st.session_state.config['leafmachine']['project']['OCR_option_llava'] = OCR_option_llava
OCR_option_llava_bit = st.radio(
"Select the LLaVA quantization level",
options_llava_bit,
index=default_index_llava_bit,
help="",captions=captions_llava_bit,
)
st.session_state.config['leafmachine']['project']['OCR_option_llava_bit'] = OCR_option_llava_bit
# st.markdown("Below is an example of what the LLM would see given the choice of OCR ensemble. One, two, or three version of OCR can be fed into the LLM prompt. Typically, 'printed + handwritten' works well. If you have a GPU then you can enable trOCR.")
# if (OCR_option == 'hand') and not do_use_trOCR:
# st.text_area(label='Handwritten/Printed',placeholder=demo_text_h,disabled=True, label_visibility='visible', height=150)
# elif (OCR_option == 'normal') and not do_use_trOCR:
# st.text_area(label='Printed',placeholder=demo_text_p,disabled=True, label_visibility='visible', height=150)
# elif (OCR_option == 'both') and not do_use_trOCR:
# st.text_area(label='Handwritten/Printed + Printed',placeholder=demo_text_b,disabled=True, label_visibility='visible', height=150)
# elif (OCR_option == 'both') and do_use_trOCR:
# st.text_area(label='Handwritten/Printed + Printed + trOCR',placeholder=demo_text_trb,disabled=True, label_visibility='visible', height=150)
# elif (OCR_option == 'normal') and do_use_trOCR:
# st.text_area(label='Printed + trOCR',placeholder=demo_text_trp,disabled=True, label_visibility='visible', height=150)
# elif (OCR_option == 'hand') and do_use_trOCR:
# st.text_area(label='Handwritten/Printed + trOCR',placeholder=demo_text_trh,disabled=True, label_visibility='visible', height=150)
def is_valid_huggingface_model_path(model_path):
from transformers import AutoConfig
try:
# Attempt to load the model configuration from Hugging Face Model Hub
config = AutoConfig.from_pretrained(model_path)
return True # If the configuration loads successfully, the model path is valid
except Exception as e:
# If loading the model configuration fails, the model path is not valid
return False
@st.cache_data
def show_collage():
# Load the image only if it's not already in the session state
if "demo_collage" not in st.session_state:
# ba = os.path.join(st.session_state.dir_home, 'demo', 'ba', 'ba2.png')
ba = os.path.join(st.session_state.dir_home, 'demo', 'ba', 'ba2.png')
st.session_state["demo_collage"] = Image.open(ba)
with st.expander(":frame_with_picture: View an example of the LeafMachine2 collage image"):
st.image(st.session_state["demo_collage"], caption='LeafMachine2 Collage', output_format="PNG")
@st.cache_data
def show_ocr():
if "demo_overlay" not in st.session_state:
# ocr = os.path.join(st.session_state.dir_home,'demo', 'ba','ocr.png')
ocr = os.path.join(st.session_state.dir_home,'demo', 'ba','ocr2.png')
st.session_state["demo_overlay"] = Image.open(ocr)
with st.expander(":frame_with_picture: View an example of the OCR overlay image"):
st.image(st.session_state["demo_overlay"], caption='OCR Overlay Images', output_format = "PNG")
# st.image(st.session_state["demo_overlay"], caption='OCR Overlay Images', output_format = "JPEG")
def content_collage_overlay():
st.markdown("---")
col_collage, col_overlay = st.columns([4,4])
with col_collage:
st.header('LeafMachine2 Label Collage')
st.info("NOTE: We strongly recommend enabling LeafMachine2 cropping if your images are full sized herbarium sheet. Often, the OCR algorithm struggles with full sheets, but works well with the collage images. We have disabled the collage by default for this Hugging Face Space because the Space lacks a GPU and the collage creation takes a bit longer.")
default_crops = st.session_state.config['leafmachine']['cropped_components']['save_cropped_annotations']
st.markdown("Prior to transcription, use LeafMachine2 to crop all labels from input images to create label collages for each specimen image. Showing just the text labels to the OCR algorithms significantly improves performance. This runs slowly on the free Hugging Face Space, but runs quickly with a fast CPU or any GPU.")
st.markdown("Images that are mostly text (like a scanned notecard, or already cropped images) do not require LM2 collage.")
if st.session_state.is_hf:
st.session_state.config['leafmachine']['use_RGB_label_images'] = st.checkbox(":rainbow[Use LeafMachine2 label collage for transcriptions]", st.session_state.config['leafmachine'].get('use_RGB_label_images', False), key='do make collage hf')
else:
st.session_state.config['leafmachine']['use_RGB_label_images'] = st.checkbox(":rainbow[Use LeafMachine2 label collage for transcriptions]", st.session_state.config['leafmachine'].get('use_RGB_label_images', True), key='do make collage local')
option_selected_crops = st.multiselect(label="Components to crop",
options=['ruler', 'barcode','label', 'colorcard','map','envelope','photo','attached_item','weights',
'leaf_whole', 'leaf_partial', 'leaflet', 'seed_fruit_one', 'seed_fruit_many', 'flower_one', 'flower_many', 'bud','specimen','roots','wood'],default=default_crops)
st.session_state.config['leafmachine']['cropped_components']['save_cropped_annotations'] = option_selected_crops
show_collage()
with col_overlay:
st.header('OCR Overlay Image')
st.markdown('This will plot bounding boxes around all text that Google Vision was able to detect. If there are no boxes around text, then the OCR failed, so that missing text will not be seen by the LLM when it is creating the JSON object. The created image will be viewable in the VoucherVisionEditor.')
do_create_OCR_helper_image = st.checkbox("Create image showing an overlay of the OCR detections",value=st.session_state.config['leafmachine']['do_create_OCR_helper_image'],disabled=True)
st.session_state.config['leafmachine']['do_create_OCR_helper_image'] = do_create_OCR_helper_image
show_ocr()
def content_archival_components():
st.write("---")
st.header('Archival Components')
ACD_version = st.selectbox("Archival Component Detector (ACD) Version", ["Version 2.1", "Version 2.2"])
ACD_confidence_default = int(st.session_state.config['leafmachine']['archival_component_detector']['minimum_confidence_threshold'] * 100)
ACD_confidence = st.number_input("ACD Confidence Threshold (%)", min_value=0, max_value=100,value=ACD_confidence_default)
st.session_state.config['leafmachine']['archival_component_detector']['minimum_confidence_threshold'] = float(ACD_confidence/100)
st.session_state.config['leafmachine']['archival_component_detector']['do_save_prediction_overlay_images'] = st.checkbox("Save Archival Prediction Overlay Images", st.session_state.config['leafmachine']['archival_component_detector'].get('do_save_prediction_overlay_images', True))
st.session_state.config['leafmachine']['archival_component_detector']['ignore_objects_for_overlay'] = st.multiselect("Hide Archival Components in Prediction Overlay Images",
['ruler', 'barcode','label', 'colorcard','map','envelope','photo','attached_item','weights',],
default=[])
# Depending on the selected version, set the configuration
if ACD_version == "Version 2.1":
st.session_state.config['leafmachine']['archival_component_detector']['detector_type'] = 'Archival_Detector'
st.session_state.config['leafmachine']['archival_component_detector']['detector_version'] = 'PREP_final'
st.session_state.config['leafmachine']['archival_component_detector']['detector_iteration'] = 'PREP_final'
st.session_state.config['leafmachine']['archival_component_detector']['detector_weights'] = 'best.pt'
elif ACD_version == "Version 2.2": #TODO update this to version 2.2
st.session_state.config['leafmachine']['archival_component_detector']['detector_type'] = 'Archival_Detector'
st.session_state.config['leafmachine']['archival_component_detector']['detector_version'] = 'PREP_final'
st.session_state.config['leafmachine']['archival_component_detector']['detector_iteration'] = 'PREP_final'
st.session_state.config['leafmachine']['archival_component_detector']['detector_weights'] = 'best.pt'
def content_processing_options():
st.write("---")
st.header('Processing Options')
col_processing_1, col_processing_2 = st.columns([2,2,])
with col_processing_1:
st.subheader('Compute Options')
st.session_state.config['leafmachine']['project']['num_workers'] = st.number_input("Number of CPU workers", value=st.session_state.config['leafmachine']['project'].get('num_workers', 1), disabled=False)
st.session_state.config['leafmachine']['project']['batch_size'] = st.number_input("Batch size", value=st.session_state.config['leafmachine']['project'].get('batch_size', 500), help='Sets the batch size for the LeafMachine2 cropping. If computer RAM is filled, lower this value to ~100.')
st.session_state.config['leafmachine']['project']['pdf_conversion_dpi'] = st.number_input("PDF conversion DPI", value=st.session_state.config['leafmachine']['project'].get('pdf_conversion_dpi', 100), help='DPI of the JPG created from the page of a PDF. 100 should be fine for most cases, but 200 or 300 might be better for large images.')
with col_processing_2:
st.subheader('Filename Prefix Handling')
st.session_state.config['leafmachine']['project']['prefix_removal'] = st.text_input("Remove prefix from catalog number", st.session_state.config['leafmachine']['project'].get('prefix_removal', ''),placeholder="e.g. MICH-V-")
st.session_state.config['leafmachine']['project']['suffix_removal'] = st.text_input("Remove suffix from catalog number", st.session_state.config['leafmachine']['project'].get('suffix_removal', ''),placeholder="e.g. _B")
st.session_state.config['leafmachine']['project']['catalog_numerical_only'] = st.checkbox("Require 'Catalog Number' to be numerical only", st.session_state.config['leafmachine']['project'].get('catalog_numerical_only', True))
### Logging and Image Validation - col_v1
st.write("---")
col_v1, col_v2 = st.columns(2)
with col_v1:
st.header('Logging and Image Validation')
option_check_illegal = st.checkbox("Check for illegal filenames", value=st.session_state.config['leafmachine']['do']['check_for_illegal_filenames'])
st.session_state.config['leafmachine']['do']['check_for_illegal_filenames'] = option_check_illegal
option_skip_vertical = st.checkbox("Skip vertical image requirement (e.g. horizontal PDFs)", value=st.session_state.config['leafmachine']['do']['skip_vertical'],help='LeafMachine2 label collage requires images to have vertical aspect ratios for stability. If your input images have a horizonatal aspect ratio, try skipping the vertical requirement first, look for strange behavior, and then reassess. If your image/PDFs are already closeups and you do not need the collage, then skipping the vertical requirement is the right choice.')
st.session_state.config['leafmachine']['do']['skip_vertical'] = option_skip_vertical
st.session_state.config['leafmachine']['do']['check_for_corrupt_images_make_vertical'] = st.checkbox("Check for corrupt images", st.session_state.config['leafmachine']['do'].get('check_for_corrupt_images_make_vertical', True),disabled=True)
st.session_state.config['leafmachine']['print']['verbose'] = st.checkbox("Print verbose", st.session_state.config['leafmachine']['print'].get('verbose', True))
st.session_state.config['leafmachine']['print']['optional_warnings'] = st.checkbox("Show optional warnings", st.session_state.config['leafmachine']['print'].get('optional_warnings', True))
log_level = st.session_state.config['leafmachine']['logging'].get('log_level', None)
log_level_display = log_level if log_level is not None else 'default'
selected_log_level = st.selectbox("Logging Level", ['default', 'DEBUG', 'INFO', 'WARNING', 'ERROR'], index=['default', 'DEBUG', 'INFO', 'WARNING', 'ERROR'].index(log_level_display))
if selected_log_level == 'default':
st.session_state.config['leafmachine']['logging']['log_level'] = None
else:
st.session_state.config['leafmachine']['logging']['log_level'] = selected_log_level
with col_v2:
# print(f"Number of GPUs: {st.session_state.num_gpus}")
# print(f"GPU Details: {st.session_state.gpu_dict}")
# print(f"Total VRAM: {st.session_state.total_vram_gb} GB")
# print(f"Capability Score: {st.session_state.capability_score}")
st.header('System GPU Information')
st.markdown(f"**Torch CUDA:** {torch.cuda.is_available()}")
st.markdown(f"**Number of GPUs:** {st.session_state.num_gpus}")
if st.session_state.num_gpus > 0:
st.markdown("**GPU Details:**")
for gpu_id, vram in st.session_state.gpu_dict.items():
st.text(f"{gpu_id}: {vram}")
st.markdown(f"**Total VRAM:** {st.session_state.total_vram_gb} GB")
st.markdown(f"**Capability Score:** {st.session_state.capability_score}")
else:
st.warning("No GPUs detected in the system.")
def content_tab_domain():
st.write("---")
st.header('Embeddings Database')
col_emb_1, col_emb_2 = st.columns([4,2])
with col_emb_1:
st.markdown(
"""
VoucherVision includes the option of using domain knowledge inside of the dynamically generated prompts. The OCR text is queried against a database of existing label transcriptions. The most similar existing transcriptions act as an example of what the LLM should emulate and are shown to the LLM as JSON objects. VoucherVision uses cosine similarity search to return the most similar existing transcription.
- Note: Using domain knowledge may increase the chance that foreign text is included in the final transcription
- Disabling this feature will show the LLM multiple examples of an empty JSON skeleton structure instead
- Enabling this option requires a GPU with at least 8GB of VRAM
- The domain knowledge files can be located in the directory "../VoucherVision/domain_knowledge". On first run the embeddings database must be created, which takes time. If the database creation runs each time you use VoucherVision, then something is wrong.
"""
)
st.write(f"Domain Knowledge is only available for the following prompts:")
for available_prompts in ModelMaps.PROMPTS_THAT_NEED_DOMAIN_KNOWLEDGE:
st.markdown(f"- {available_prompts}")
if st.session_state.config['leafmachine']['project']['prompt_version'] in ModelMaps.PROMPTS_THAT_NEED_DOMAIN_KNOWLEDGE:
st.session_state.config['leafmachine']['project']['use_domain_knowledge'] = st.checkbox("Use domain knowledge", True, disabled=True)
else:
st.session_state.config['leafmachine']['project']['use_domain_knowledge'] = st.checkbox("Use domain knowledge", False, disabled=True)
st.write("")
if st.session_state.config['leafmachine']['project']['use_domain_knowledge']:
st.session_state.config['leafmachine']['project']['embeddings_database_name'] = st.text_input("Embeddings database name (only use underscores)", st.session_state.config['leafmachine']['project'].get('embeddings_database_name', ''))
st.session_state.config['leafmachine']['project']['build_new_embeddings_database'] = st.checkbox("Build *new* embeddings database", st.session_state.config['leafmachine']['project'].get('build_new_embeddings_database', False))
st.session_state.config['leafmachine']['project']['path_to_domain_knowledge_xlsx'] = st.text_input("Path to domain knowledge CSV file (will be used to create new embeddings database)", st.session_state.config['leafmachine']['project'].get('path_to_domain_knowledge_xlsx', ''))
else:
st.session_state.config['leafmachine']['project']['embeddings_database_name'] = st.text_input("Embeddings database name (only use underscores)", st.session_state.config['leafmachine']['project'].get('embeddings_database_name', ''), disabled=True)
st.session_state.config['leafmachine']['project']['build_new_embeddings_database'] = st.checkbox("Build *new* embeddings database", st.session_state.config['leafmachine']['project'].get('build_new_embeddings_database', False), disabled=True)
st.session_state.config['leafmachine']['project']['path_to_domain_knowledge_xlsx'] = st.text_input("Path to domain knowledge CSV file (will be used to create new embeddings database)", st.session_state.config['leafmachine']['project'].get('path_to_domain_knowledge_xlsx', ''), disabled=True)
def content_space_saver():
st.write("---")
st.subheader("Space Saving Options")
col_ss_1, col_ss_2 = st.columns([2,2])
with col_ss_1:
st.write("Several folders are created and populated with data during the VoucherVision transcription process.")
st.write("Below are several options that will allow you to automatically delete temporary files that you may not need for everyday operations.")
st.write("VoucherVision creates the following folders. Folders marked with a :star: are required if you want to use VoucherVisionEditor for quality control.")
st.write("`../[Run Name]/Archival_Components`")
st.write("`../[Run Name]/Config_File`")
st.write("`../[Run Name]/Cropped_Images` :star:")
st.write("`../[Run Name]/Logs`")
st.write("`../[Run Name]/Original_Images` :star:")
st.write("`../[Run Name]/Transcription` :star:")
with col_ss_2:
st.session_state.config['leafmachine']['project']['delete_temps_keep_VVE'] = st.checkbox("Delete Temporary Files (KEEP files required for VoucherVisionEditor)", st.session_state.config['leafmachine']['project'].get('delete_temps_keep_VVE', False))
st.session_state.config['leafmachine']['project']['delete_all_temps'] = st.checkbox("Keep only the final transcription file", st.session_state.config['leafmachine']['project'].get('delete_all_temps', False),help="*WARNING:* This limits your ability to do quality assurance. This will delete all folders created by VoucherVision, leaving only the `transcription.xlsx` file.")
#################################################################################################################################################
# render_expense_report_summary #################################################################################################################
#################################################################################################################################################
@st.cache_data
def render_expense_report_summary():
expense_summary = st.session_state.expense_summary
expense_report = st.session_state.expense_report
st.header('Expense Report Summary')
if not expense_summary:
st.warning('No expense report data available.')
else:
st.metric(label="Total Cost", value=f"${round(expense_summary['total_cost_sum'], 4):,}")
col1, col2 = st.columns(2)
# Run count and total costs
with col1:
st.metric(label="Run Count", value=expense_summary['run_count'])
st.metric(label="Tokens In", value=f"{expense_summary['tokens_in_sum']:,}")
# Token information
with col2:
st.metric(label="Total Images", value=expense_summary['n_images_sum'])
st.metric(label="Tokens Out", value=f"{expense_summary['tokens_out_sum']:,}")
# Calculate cost proportion per image for each API version
st.subheader('Average Cost per Image by API Version')
cost_labels = []
cost_values = []
total_images = 0
cost_per_image_dict = {}
# Iterate through the expense report to accumulate costs and image counts
for index, row in expense_report.iterrows():
api_version = row['api_version']
total_cost = row['total_cost']
n_images = row['n_images']
total_images += n_images # Keep track of total images processed
if api_version not in cost_per_image_dict:
cost_per_image_dict[api_version] = {'total_cost': 0, 'n_images': 0}
cost_per_image_dict[api_version]['total_cost'] += total_cost
cost_per_image_dict[api_version]['n_images'] += n_images
api_versions = list(cost_per_image_dict.keys())
colors = [ModelMaps.COLORS_EXPENSE_REPORT[version] if version in ModelMaps.COLORS_EXPENSE_REPORT else '#DDDDDD' for version in api_versions]
# Calculate the cost per image for each API version
for version, cost_data in cost_per_image_dict.items():
total_cost = cost_data['total_cost']
n_images = cost_data['n_images']
# Calculate the cost per image for this version
cost_per_image = total_cost / n_images if n_images > 0 else 0
cost_labels.append(version)
cost_values.append(cost_per_image)
# Generate the pie chart
cost_pie_chart = go.Figure(data=[go.Pie(labels=cost_labels, values=cost_values, hole=.3)])
# Update traces for custom text in hoverinfo, displaying cost with a dollar sign and two decimal places
cost_pie_chart.update_traces(
marker=dict(colors=colors),
text=[f"${value:.4f}" for value in cost_values], # Formats the cost as a string with a dollar sign and two decimals
textinfo='percent+label',
hoverinfo='label+percent+text' # Adds custom text (formatted cost) to the hover information
)
st.plotly_chart(cost_pie_chart, use_container_width=True)
st.subheader('Proportion of Total Cost by API Version')
cost_labels = []
cost_proportions = []
total_cost_by_version = {}
# Sum the total cost for each API version
for index, row in expense_report.iterrows():
api_version = row['api_version']
total_cost = row['total_cost']
if api_version not in total_cost_by_version:
total_cost_by_version[api_version] = 0
total_cost_by_version[api_version] += total_cost
# Calculate the combined total cost for all versions
combined_total_cost = sum(total_cost_by_version.values())
# Calculate the proportion of total cost for each API version
for version, total_cost in total_cost_by_version.items():
proportion = (total_cost / combined_total_cost) * 100 if combined_total_cost > 0 else 0
cost_labels.append(version)
cost_proportions.append(proportion)
# Generate the pie chart
cost_pie_chart = go.Figure(data=[go.Pie(labels=cost_labels, values=cost_proportions, hole=.3)])
# Update traces for custom text in hoverinfo
cost_pie_chart.update_traces(
marker=dict(colors=colors),
text=[f"${cost:.4f}" for cost in total_cost_by_version.values()], # This will format the cost to 2 decimal places
textinfo='percent+label',
hoverinfo='label+percent+text' # This tells Plotly to show the label, percent, and custom text (cost) on hover
)
st.plotly_chart(cost_pie_chart, use_container_width=True)
# API version usage percentages pie chart
st.subheader('Runs by API Version')
api_versions = list(expense_summary['api_version_percentages'].keys())
percentages = [expense_summary['api_version_percentages'][version] for version in api_versions]
pie_chart = go.Figure(data=[go.Pie(labels=api_versions, values=percentages, hole=.3)])
pie_chart.update_layout(margin=dict(t=0, b=0, l=0, r=0))
pie_chart.update_traces(marker=dict(colors=colors),)
st.plotly_chart(pie_chart, use_container_width=True)
def content_less_used():
st.write('---')
st.write(':octagonal_sign: ***NOTE:*** Settings below are not relevant for most projects. Some settings below may not be reflected in saved settings files and would need to be set each time.')
#################################################################################################################################################
# Sidebar #######################################################################################################################################
#################################################################################################################################################
def sidebar_content():
if not os.path.exists(os.path.join(st.session_state.dir_home,'expense_report')):
validate_dir(os.path.join(st.session_state.dir_home,'expense_report'))
expense_report_path = os.path.join(st.session_state.dir_home, 'expense_report', 'expense_report.csv')
if os.path.exists(expense_report_path):
# File exists, proceed with summarization
st.session_state.expense_summary, st.session_state.expense_report = summarize_expense_report(expense_report_path)
render_expense_report_summary()
else:
# File does not exist, handle this case appropriately
# For example, you could set the session state variables to None or an empty value
st.session_state.expense_summary, st.session_state.expense_report = None, None
st.header('Expense Report Summary')
st.write('Available after first run...')
#################################################################################################################################################
# Routing Function ##############################################################################################################################
#################################################################################################################################################
def main():
with st.sidebar:
sidebar_content()
# Main App
content_header()
col_input, col_gallery = st.columns([4,8])
content_project_settings(col_input)
content_input_images(col_input, col_gallery)
col3, col4 = st.columns([1,1])
with col3:
content_prompt_and_llm_version()
with col4:
content_api_check()
content_ocr_method()
content_collage_overlay()
content_tools()
content_llm_cost()
content_processing_options()
content_less_used()
with st.expander("View additional settings"):
content_archival_components()
content_space_saver()
#################################################################################################################################################
# Main ##########################################################################################################################################
#################################################################################################################################################
do_print_profiler = False
if st.session_state['is_hf']:
# if st.session_state.proceed_to_build_llm_prompt:
# build_LLM_prompt_config()
if st.session_state.proceed_to_main:
if do_print_profiler:
profiler = cProfile.Profile()
profiler.enable()
main()
if do_print_profiler:
profiler.disable()
stats = pstats.Stats(profiler).sort_stats('cumulative')
stats.print_stats(30)
else:
if not st.session_state.private_file:
create_private_file()
# elif st.session_state.proceed_to_build_llm_prompt:
# build_LLM_prompt_config()
elif st.session_state.proceed_to_private and not st.session_state['is_hf']:
create_private_file()
elif st.session_state.proceed_to_main:
if do_print_profiler:
profiler = cProfile.Profile()
profiler.enable()
main()
if do_print_profiler:
profiler.disable()
stats = pstats.Stats(profiler).sort_stats('cumulative')
stats.print_stats(30)