Major update. Support for 15 LLMs, World Flora Online taxonomy validation, geolocation, 2 OCR methods, significant UI changes, stability improvements, consistent JSON parsing

.gitignore

@@ -19,6 +19,8 @@ venv_LM2_38/
 venv_LM2/
 venv_VV/
 tests/
+uploads/
+uploads_small/
 .vscode/
 runs/
 KP_Test/

app.py

@@ -15,12 +15,30 @@ from vouchervision.vouchervision_main import voucher_vision, voucher_vision_OCR_
 from vouchervision.general_utils import test_GPU, get_cfg_from_full_path, summarize_expense_report, create_google_ocr_yaml_config, validate_dir
 from vouchervision.model_maps import ModelMaps
 from vouchervision.API_validation import APIvalidation
-from vouchervision.utils_hf import upload_to_drive, image_to_base64, setup_streamlit_config, save_uploaded_file, check_prompt_yaml_filename
+from vouchervision.utils_hf import upload_to_drive, image_to_base64, setup_streamlit_config, save_uploaded_file, check_prompt_yaml_filename, save_uploaded_local
+
+
+
+#################################################################################################################################################
+# Initializations ###############################################################################################################################
+#################################################################################################################################################
+        
+st.set_page_config(layout="wide", page_icon='img/icon.ico', page_title='VoucherVision')
+
+# Parse the 'is_hf' argument and set it in session state
+if 'is_hf' not in st.session_state:
+    st.session_state['is_hf'] = True
 
 
 ########################################################################################################
 ###  ADDED FOR HUGGING FACE                                                                         ####
 ########################################################################################################
+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)
+
 if 'uploader_idk' not in st.session_state:
     st.session_state['uploader_idk'] = 1
 if 'input_list_small' not in st.session_state:
@@ -31,76 +49,157 @@ 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'))
 
-MAX_GALLERY_IMAGES = 50
-GALLERY_IMAGE_SIZE = 128
+MAX_GALLERY_IMAGES = 20
+GALLERY_IMAGE_SIZE = 96
 
 
 
-def content_input_images_hf():
+def content_input_images(col_left, col_right):
     st.write('---')
-    col1, col2 = st.columns([2,8])
+    # 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'], 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:
+            if uploaded_files:
+                # Clear input image gallery and input list
+                clear_image_gallery()
 
-    with col1:
-        st.header('Run name')
-        st.session_state.config['leafmachine']['project']['run_name'] = st.text_input("Run name", st.session_state.config['leafmachine']['project'].get('run_name', ''),
-                                                                                        label_visibility='collapsed',key=995)
-        st.write("Run name will be the name of the final zipped folder.")
+                # Process the new iamges
+                for uploaded_file in uploaded_files:
+                    file_path = save_uploaded_file(st.session_state['dir_uploaded_images'], uploaded_file)
+                    st.session_state['input_list'].append(file_path)
 
-        st.write('---')
-        st.header('Input Images')
-        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'], accept_multiple_files=True, key=st.session_state['uploader_idk'])
-        if uploaded_files:
-            # Clear input image gallery and input list
-            clear_image_gallery()
-
-            # Process the new iamges
-            for uploaded_file in uploaded_files:
-                file_path = save_uploaded_file(st.session_state['dir_uploaded_images'], uploaded_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)  
-                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)
-                print(uploaded_file.name)
-
-            # Set the local images to the uploaded images
-            st.session_state.config['leafmachine']['project']['dir_images_local'] = st.session_state['dir_uploaded_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'] = f" {n_images} images"
-            uploaded_files = None
-            st.session_state['uploader_idk'] += 1
-            st.info(f"Processing **{n_images}** images from {st.session_state.config['leafmachine']['project']['dir_images_local']}")
-
-
-        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 col2:
-        if st.session_state['input_list_small']:
-            st.subheader('Image Gallery')
-            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']
-            st.image(images_to_display)
+                    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)
+                    print(uploaded_file.name)
+
+                # Set the local images to the uploaded images
+                st.session_state.config['leafmachine']['project']['dir_images_local'] = st.session_state['dir_uploaded_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
+                uploaded_files = None
+                st.session_state['uploader_idk'] += 1
+                st.info(f"Processing **{n_images}** 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']
+                st.image(images_to_display)
+
+        else:
+            st.session_state['view_local_gallery'] = st.toggle("View Image 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:
+                    st.image(st.session_state['input_list_small'], width=GALLERY_IMAGE_SIZE)
+                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']):
+                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 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):
     with col:
-        labale_n_images = f"Download Results for{st.session_state['processing_add_on']} Images"
+        labal_n_images = f"Download Results for {st.session_state['processing_add_on']} Images"
         with open(zip_filepath, 'rb') as f:
             bytes_io = BytesIO(f.read())
         st.download_button(
-            label=labale_n_images,
+            label=labal_n_images,
             type='primary',
             data=bytes_io,
             file_name=os.path.basename(zip_filepath),
@@ -130,9 +229,17 @@ 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'] = f" {n_images} Images"
+    st.session_state['processing_add_on'] = n_images
     clear_image_gallery()
     st.session_state['uploader_idk'] += 1
+    for file in os.listdir(st.session_state.config['leafmachine']['project']['dir_images_local']):
+        file_path = save_uploaded_file(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)  
+        file_path_small = save_uploaded_file(st.session_state['dir_uploaded_images_small'], file, img)
+        st.session_state['input_list_small'].append(file_path_small)
 
 
 def create_download_button_yaml(file_path, selected_yaml_file):
@@ -409,7 +516,7 @@ class JSONReport:
     
 
 def does_private_file_exist():
-    dir_home = os.path.dirname(os.path.dirname(__file__))
+    dir_home = os.path.dirname(__file__)
     path_cfg_private = os.path.join(dir_home, 'PRIVATE_DATA.yaml')
     return os.path.exists(path_cfg_private)
 
@@ -613,16 +720,32 @@ def get_prompt_versions(LLM_version):
 
 
 def get_private_file():
-    dir_home = os.path.dirname(os.path.dirname(__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 create_private_file(): #################################################################################### UPDATE
+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([12,2])
+    _, col_private,__= st.columns([section_left,section_mid, section_right])
+
+    
 
     if st.session_state.private_file:
         cfg_private = get_private_file()
@@ -632,219 +755,219 @@ def create_private_file(): #####################################################
         cfg_private['openai']['OPENAI_API_KEY'] =''
         
         cfg_private['openai_azure'] = {}
-        cfg_private['openai_azure']['openai_api_key'] = ''
-        cfg_private['openai_azure']['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_cloud'] = {}
-        cfg_private['google_cloud']['path_json_file'] =''
-
-        cfg_private['google_palm'] = {}
-        cfg_private['google_palm']['google_palm_api'] =''
+        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.info("***Note:*** There is a known bug with tabs in Streamlit. If you update an input field it may take you back to the 'Project Settings' tab. Changes that you made are saved, it's just an annoying glitch. We are aware of this issue and will fix it as soon as we can.")
         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.")
+        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.write("---")
-        st.subheader("Google Vision  (*Required*)")
+        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:
-
-        - **Select your Project**: If you have multiple projects, ensure you select the one where you've enabled the Vision API.
-        - **Open the Navigation Menu**: Click on the hamburger menu (three horizontal lines) in the top left corner.
-        - **Go to IAM & Admin**: In the navigation pane, hover over "IAM & Admin" and then click on "Service accounts."
-        - **Locate Your Service Account**: Find the service account for which you wish to download the JSON key. If you haven't created a service account yet, you'll need to do so by clicking the "CREATE SERVICE ACCOUNT" button at the top.
-        - **Download the JSON Key**:
-            - Click on the three dots (actions menu) on the right side of your service account name.
-            - Select "Manage keys."
-            - In the pop-up window, click on the "ADD KEY" button and select "JSON."
-            - The JSON key file will automatically be downloaded to your computer.
-        - **Store Safely**: 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.
-        """)
-        with st.container():
-            c_in_ocr, c_button_ocr = st.columns([10,2])
-            with c_in_ocr:
-                google_vision = st.text_input(label = 'Full path to Google Cloud JSON API key file', value = cfg_private['google_cloud'].get('path_json_file', ''),
-                                                 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',key='924857298734590283750932809238')
-            with c_button_ocr:
-                st.empty()
+        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"
+                })
+        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).")
-        with st.container():
-            c_in_openai, c_button_openai = st.columns([10,2])
-            with c_in_openai:
-                openai_api_key = st.text_input("openai_api_key", cfg_private['openai'].get('OPENAI_API_KEY', ''),
+        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')
-            with c_button_openai:
-                st.empty()
+
 
         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("azure_openai_api_version", cfg_private['openai_azure'].get('api_version', ''),
+        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("azure_openai_api_key", cfg_private['openai_azure'].get('openai_api_key', ''),
-                                                 help='The actual API key. Likely to be a 32-character string',
+        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("azure_openai_api_base", cfg_private['openai_azure'].get('openai_api_base', ''),
+        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("azure_openai_organization", cfg_private['openai_azure'].get('openai_organization', ''),
-                                                 help='Your organization code. Likely a short string',
+        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("azure_openai_api_type", cfg_private['openai_azure'].get('openai_api_type', ''),
+        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')
-        with st.container():
-            c_in_azure, c_button_azure = st.columns([10,2])
-            with c_button_azure:
-                st.empty()
-        
+
+        # 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("Google PaLM 2")
-        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."')
-        with st.container():
-            c_in_palm, c_button_palm = st.columns([10,2])
-            with c_in_palm:
-                google_palm = st.text_input("Google PaLM 2 API Key", cfg_private['google_palm'].get('google_palm_api', ''),
-                                                 help='The MakerSuite API key e.g. a 32-character string',
+        st.subheader("MistralAI")
+        st.markdown('Follow these [instructions](https://platform.here.com/sign-up?step=verify-identity) to generate an API key for HERE.')
+        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')
-
-        with st.container():
-            with c_button_ocr:
-                st.write("##")
-                st.button("Test OCR", on_click=test_API, args=['google_vision',c_in_ocr, 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_vision,google_palm])
-
-        with st.container():
-            with c_button_openai:
-                st.write("##")
-                st.button("Test OpenAI", on_click=test_API, args=['openai',c_in_openai, 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_vision,google_palm])
-                
-        with st.container():
-            with c_button_azure:
-                st.write("##")
-                st.button("Test Azure OpenAI", on_click=test_API, args=['azure_openai',c_in_azure, 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_vision,google_palm])
                 
-        with st.container():
-            with c_button_palm:
-                st.write("##")
-                st.button("Test PaLM 2", on_click=test_API, args=['palm',c_in_palm, 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_vision,google_palm])
+
+        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.')
+        hre_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')
+        hre_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_vision,google_palm])
+                                                                    azure_openai_api_base,azure_openai_organization,azure_openai_api_type,
+                                                                    google_application_credentials, google_project_location, google_project_id,
+                                                                    mistral_API_KEY, hre_APP_ID, hre_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
-
-def test_API(api, message_loc, 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_vision,google_palm):
-    # Save the API keys
-    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_vision,google_palm)
-    
-    with st.spinner('Performing validation checks...'):
-        if api == 'google_vision':
-            print("*** Google Vision OCR API Key ***")
-            try:
-                demo_config_path = os.path.join(st.session_state.dir_home,'demo','validation_configs','google_vision_ocr_test.yaml')
-                demo_images_path = os.path.join(st.session_state.dir_home, 'demo', 'demo_images')
-                demo_out_path = os.path.join(st.session_state.dir_home, 'demo', 'demo_output','run_name')
-                create_google_ocr_yaml_config(demo_config_path, demo_images_path, demo_out_path)
-                voucher_vision_OCR_test(demo_config_path, st.session_state.dir_home, None, demo_images_path)
-                with message_loc:
-                    st.success("Google Vision OCR API Key Valid :white_check_mark:")
-                return True
-            except Exception as e:
-                with message_loc:
-                    st.error(f"Google Vision OCR API Key Failed! {e}")
-                return False
-            
-        elif api == 'openai':
-            print("*** OpenAI API Key ***")
-            try:
-                if run_api_tests('openai'):
-                    with message_loc:
-                        st.success("OpenAI API Key Valid :white_check_mark:")
-                else:
-                    with message_loc:
-                        st.error("OpenAI API Key Failed:exclamation:")
-                    return False
-            except Exception as e:
-                with message_loc:
-                    st.error(f"OpenAI API Key Failed:exclamation: {e}")
-
-        elif api == 'azure_openai':
-            print("*** Azure OpenAI API Key ***")
-            try:
-                if run_api_tests('azure_openai'):
-                    with message_loc:
-                        st.success("Azure OpenAI API Key Valid :white_check_mark:")
-                else:
-                    with message_loc:
-                        st.error(f"Azure OpenAI API Key Failed:exclamation:")
-                    return False
-            except Exception as e:
-                with message_loc:
-                    st.error(f"Azure OpenAI API Key Failed:exclamation: {e}")
-        elif api == 'palm':
-            print("*** Google PaLM 2 API Key ***")
-            try:
-                if run_api_tests('palm'):
-                    with message_loc:
-                        st.success("Google PaLM 2 API Key Valid :white_check_mark:")
-                else:
-                    with message_loc:
-                        st.error("Google PaLM 2 API Key Failed:exclamation:")
-                    return False
-            except Exception as e:
-                with message_loc:
-                    st.error(f"Google PaLM 2 API Key Failed:exclamation: {e}")
+            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_vision,google_palm): ########################################  UPDATE
+                            azure_openai_api_base,azure_openai_organization,azure_openai_api_type,
+                            google_application_credentials, google_project_location, google_project_id,
+                            mistral_API_KEY, hre_APP_ID, hre_API_KEY): 
+    
     # Update the configuration dictionary with the new values
     cfg_private['openai']['OPENAI_API_KEY'] = openai_api_key 
 
-    cfg_private['openai_azure']['api_version'] = azure_openai_api_version
-    cfg_private['openai_azure']['openai_api_key'] = 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['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_location
+    cfg_private['google']['GOOGLE_LOCATION'] = google_project_id
 
-    cfg_private['google']['GOOGLE_APPLICATION_CREDENTIALS'] = google_vision
+    cfg_private['mistral']['MISTRAL_API_KEY'] = mistral_API_KEY
 
-    cfg_private['google']['GOOGLE_PALM_API'] = google_palm
+    cfg_private['here']['APP_ID'] = hre_APP_ID
+    cfg_private['here']['API_KEY'] = hre_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.session_state.private_file = does_private_file_exist()
+    # st.session_state.private_file = does_private_file_exist()
 
 # Function to load a YAML file and update session_state
 def load_prompt_yaml(filename):
@@ -1588,14 +1711,18 @@ def content_header():
         # st.subheader('Run VoucherVision')
         N_STEPS = 6
 
-        count_n_imgs = determine_n_images()
-        if count_n_imgs > 0:
-            st.session_state['processing_add_on'] = f" {count_n_imgs} Images"
-        else:
-            st.session_state['processing_add_on'] = ''
+        # if st.session_state.is_hf:
+        #     count_n_imgs = determine_n_images()
+        #     if count_n_imgs > 0:
+        #         st.session_state['processing_add_on'] = count_n_imgs
+        #     else:
+        #         st.session_state['processing_add_on'] = 0
 
         if check_if_usable(is_hf=st.session_state['is_hf']):
-            if st.button(f"Start Processing{st.session_state['processing_add_on']}", type='primary',use_container_width=True):
+            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 Processing"
+            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'] = {}
@@ -1750,28 +1877,16 @@ def content_header():
 
 
 
-def content_project_settings():
-     
-    st.header('Project Settings')
-    col_project_1, col_project_2 = st.columns([11,1])
-    ### Project
-    with col_project_1:
+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)
         st.session_state.config['leafmachine']['project']['dir_output'] = st.text_input("Output directory", st.session_state.config['leafmachine']['project'].get('dir_output', ''))
-    
-
-
-def content_input_images():
-    st.header('Input Images')
-    col_local_1, col_local_2 = st.columns([11,1])  
-    with col_local_1:
-        ### 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)
         
 
 
-
 def content_llm_cost():
     st.write("---")
     st.header('LLM Cost Calculator')
@@ -1881,10 +1996,11 @@ def content_api_check():
             st.session_state['API_rechecked'] = True
             st.rerun()
         # with col_llm_2c:
-        if st.button("Edit API Keys"):
-            st.session_state.proceed_to_private = True
-            st.rerun()
-            
+        if not st.session_state.is_hf:
+            if st.button("Edit API Keys"):
+                st.session_state.proceed_to_private = True
+                st.rerun()
+                
 
     
     
@@ -1940,8 +2056,7 @@ def content_collage_overlay():
         st.session_state.config['leafmachine']['do_create_OCR_helper_image'] = do_create_OCR_helper_image
         
         
-        do_use_trOCR = st.checkbox("Supplement Google Vision OCR with trOCR (handwriting OCR) via 'microsoft/trocr-large-handwritten'", value=st.session_state.config['leafmachine']['project']['do_use_trOCR'],disabled=st.session_state['lacks_GPU'])
-        st.session_state.config['leafmachine']['project']['do_use_trOCR'] = do_use_trOCR
+        
 
         # Get the current OCR option from session state
         OCR_option = st.session_state.config['leafmachine']['project']['OCR_option']
@@ -1972,6 +2087,11 @@ def content_collage_overlay():
             OCR_option = 'both'
         else:
             raise
+        
+        st.write("Supplement Google Vision OCR with trOCR (handwriting OCR) using `microsoft/trocr-base-handwritten`. This option requires Google Vision API and a GPU.")
+        do_use_trOCR = st.checkbox("Enable trOCR", value=st.session_state.config['leafmachine']['project']['do_use_trOCR'],disabled=st.session_state['lacks_GPU'])
+        st.session_state.config['leafmachine']['project']['do_use_trOCR'] = do_use_trOCR
+
 
         st.session_state.config['leafmachine']['project']['OCR_option'] = OCR_option
         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.")
@@ -2267,19 +2387,21 @@ def main():
     content_header()
 
     
+    col_input, col_gallery = st.columns([4,8])
+    content_project_settings(col_input)
+    content_input_images(col_input, col_gallery)
 
-    if st.session_state['is_hf']:
-        content_project_settings()
-        content_input_images_hf()
-    else:
-        col1, col2 = st.columns([1,1])
-        with col1:
-            content_project_settings()
-        with col2:
-            content_input_images()
+    # if st.session_state['is_hf']:
+    #     content_project_settings()
+    #     content_input_images_hf()
+    # else:
+    #     col1, col2 = st.columns([1,1])
+    #     with col1:
+    #         content_project_settings()
+    #     with col2:
+    #         content_input_images()
 
 
-    st.write("---")
     col3, col4 = st.columns([1,1])
     with col3:
         content_prompt_and_llm_version()
@@ -2295,15 +2417,7 @@ def main():
 
 
 
-#################################################################################################################################################
-# Initializations ###############################################################################################################################
-#################################################################################################################################################
-        
-st.set_page_config(layout="wide", page_icon='img/icon.ico', page_title='VoucherVision')
 
-# Parse the 'is_hf' argument and set it in session state
-if 'is_hf' not in st.session_state:
-    st.session_state['is_hf'] = True
   
 
 #################################################################################################################################################
@@ -2311,47 +2425,42 @@ if 'is_hf' not in st.session_state:
 #################################################################################################################################################
     
 
-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)
+
+
+
 
 
 if st.session_state['is_hf']:
     if 'proceed_to_main' not in st.session_state:
         st.session_state.proceed_to_main = True
-    print(f"proceed_to_main {st.session_state['proceed_to_main']}")
     
     if 'proceed_to_private' not in st.session_state:
         st.session_state.proceed_to_private = False 
-    print(f"proceed_to_private {st.session_state['proceed_to_private']}")
 
     if 'private_file' not in st.session_state:
         st.session_state.private_file = True 
-    print(f"private_file {st.session_state['private_file']}")
 
 else:
     if 'proceed_to_main' not in st.session_state:
-        st.session_state.proceed_to_main = True  # New state variable to control the flow
-    print(f"proceed_to_main {st.session_state['proceed_to_main']}")
+        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
-    print(f"private_file2 {st.session_state['private_file']}")
-    print(f"proceed_to_main2 {st.session_state['proceed_to_main']}")
 
     if 'proceed_to_private' not in st.session_state:
         st.session_state.proceed_to_private = False  # New state variable to control the flow
-    print(f"proceed_to_private2 {st.session_state['proceed_to_private']}")
+
 
 
 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 'processing_add_on' not in st.session_state:
-    st.session_state['processing_add_on'] = ''
+    st.session_state['processing_add_on'] = 0
+
 
 if 'formatted_json' not in st.session_state:
     st.session_state['formatted_json'] = None
@@ -2360,9 +2469,11 @@ if 'formatted_json_WFO' not in st.session_state:
 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 'present_annotations' not in st.session_state:
@@ -2376,18 +2487,15 @@ if 'API_checked' not in st.session_state:
 if 'API_rechecked' not in st.session_state:
     st.session_state['API_rechecked'] = False 
 
+
 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 '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'))
+
+
 
 if 'cost_openai' not in st.session_state:
     st.session_state['cost_openai'] = None
@@ -2400,6 +2508,7 @@ if 'cost_mistral' not in st.session_state:
 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:
@@ -2407,16 +2516,13 @@ if 'loaded_settings_filename' not in st.session_state:
 if 'zip_filepath' not in st.session_state:
     st.session_state['zip_filepath'] = None
 
+
 # Initialize session_state variables if they don't exist
 if 'prompt_info' not in st.session_state:
     st.session_state['prompt_info'] = {}
 if 'rules' not in st.session_state:
     st.session_state['rules'] = {}
-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',]
+
 
 # These are the fields that are in SLTPvA that are not required by another parsing valication function:
 #     "identifiedBy": "M.W. Lyon, Jr.",
@@ -2427,7 +2533,11 @@ if 'required_fields' not in st.session_state:
 #     "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 'proceed_to_build_llm_prompt' not in st.session_state:
@@ -2441,46 +2551,27 @@ if 'proceed_to_api_keys' not in st.session_state:
 if 'proceed_to_space_saver' not in st.session_state:
     st.session_state.proceed_to_space_saver = False  
 
+
 #################################################################################################################################################
 # Main ##########################################################################################################################################
 #################################################################################################################################################
-print(f"proceed_to_main3 {st.session_state['proceed_to_main']}")
-print(f"is_hf3 {st.session_state['is_hf']}")
-print(f"private_file3 {st.session_state['private_file']}")
-print(f"proceed_to_build_llm_prompt3 {st.session_state['proceed_to_build_llm_prompt']}")
-print(f"proceed_to_private3 {st.session_state['proceed_to_private']}")
-
-# if not st.session_state.private_file and not st.session_state['is_hf']:
-#     create_private_file()
-# elif st.session_state.proceed_to_build_llm_prompt:
-if 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:
-    main()
-
-
-
-
-
+if st.session_state['is_hf']:
+    if st.session_state.proceed_to_build_llm_prompt:
+        build_LLM_prompt_config()
+    elif st.session_state.proceed_to_main:
+        main()
+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:
+        main()
 
 
-# print(f"proceed_to_main3 {st.session_state['proceed_to_main']}")
-# print(f"is_hf3 {st.session_state['is_hf']}")
-# print(f"private_file3 {st.session_state['private_file']}")
-# print(f"proceed_to_build_llm_prompt3 {st.session_state['proceed_to_build_llm_prompt']}")
-# print(f"proceed_to_private3 {st.session_state['proceed_to_private']}")
 
-# # if not st.session_state.private_file and not st.session_state['is_hf']:
-# #     create_private_file()
-# # elif st.session_state.proceed_to_build_llm_prompt:
-# if 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:
-#     main()
 
 
 

run_VoucherVision.py

@@ -9,6 +9,8 @@ import os, sys
 #     st.write("filename:", uploaded_file.name)
 #     st.write(bytes_data)
 
+# pip install protobuf==3.20.0
+
 
 def resolve_path(path):
     resolved_path = os.path.abspath(os.path.join(os.getcwd(), path))
@@ -29,7 +31,7 @@ if __name__ == "__main__":
         # "--server.port=8545",
         "--server.port=8546",
         # Toggle below for HF vs Local
-        "--is_hf=1",
+        # "--is_hf=1",
         # "--is_hf=0",
     ]
     sys.exit(stcli.main())

vouchervision/API_validation.py

@@ -7,6 +7,9 @@ from vertexai.language_models import TextGenerationModel
 from vertexai.preview.generative_models import GenerativeModel
 from google.cloud import vision
 from google.cloud import vision_v1p3beta1 as vision_beta
+# from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_google_vertexai import VertexAI
+
 
 from datetime import datetime
 import google.generativeai as genai
@@ -57,7 +60,7 @@ class APIvalidation:
                 model = AzureChatOpenAI(
                     deployment_name = 'gpt-35-turbo',#'gpt-35-turbo',
                     openai_api_version = self.cfg_private['openai_azure']['OPENAI_API_VERSION'],
-                    openai_api_key = self.cfg_private['openai_azure']['OPENAI_API_KEY'],
+                    openai_api_key = self.cfg_private['openai_azure']['OPENAI_API_KEY_AZURE'],
                     azure_endpoint = self.cfg_private['openai_azure']['OPENAI_API_BASE'],
                     openai_organization = self.cfg_private['openai_azure']['OPENAI_ORGANIZATION'],
                 )
@@ -171,7 +174,8 @@ class APIvalidation:
 
 
     def check_google_vertex_genai_api_key(self):
-        results = {"palm2": False, "gemini": False}
+        results = {"palm2": False, "gemini": False, "palm2_langchain": False}
+
 
         try:
             model = TextGenerationModel.from_pretrained("text-bison@001")
@@ -186,6 +190,24 @@ class APIvalidation:
         except Exception as e:
             # print(f"palm2 fail2 [{e}]")
             print(f"palm2 fail2")
+
+        try:
+            # https://python.langchain.com/docs/integrations/llms/google_vertex_ai_palm
+            # os.environ['GOOGLE_API_KEY'] = "AIzaSyAHOH1w1qV7C3jS4W7QFyoaTGUwZIgS5ig"
+            # genai.configure(api_key='AIzaSyC8xvu6t9fb5dTah3hpgg_rwwR5G5kianI')
+            # model = ChatGoogleGenerativeAI(model="text-bison@001")
+            model = VertexAI(model="text-bison@001", max_output_tokens=10)
+            response = model.predict("Hello")
+            test_response_palm2 = response
+            if test_response_palm2:
+                results["palm2_langchain"] = True
+                print(f"palm2_langchain pass [{test_response_palm2}]")
+            else:
+                print(f"palm2_langchain fail [{test_response_palm2}]")
+
+        except Exception as e:
+            print(f"palm2 fail2 [{e}]")
+            print(f"palm2_langchain fail2")
             
 
         try:
@@ -238,7 +260,7 @@ class APIvalidation:
             k_opencage = os.getenv('OPENCAGE_API_KEY')
         else:
             k_OPENAI_API_KEY = self.cfg_private['openai']['OPENAI_API_KEY']
-            k_openai_azure = self.cfg_private['openai_azure']['OPENAI_API_VERSION']
+            k_openai_azure = self.cfg_private['openai_azure']['OPENAI_API_KEY_AZURE']
 
             k_project_id = self.cfg_private['google']['GOOGLE_PROJECT_ID']
             k_location = self.cfg_private['google']['GOOGLE_LOCATION']
@@ -295,6 +317,10 @@ class APIvalidation:
                 present_keys.append('Palm2 (Valid)')
             else:
                 present_keys.append('Palm2 (Invalid)')
+            if google_results['palm2_langchain']:
+                present_keys.append('Palm2 LangChain (Valid)')
+            else:
+                present_keys.append('Palm2 LangChain (Invalid)')
             if google_results['gemini']:
                 present_keys.append('Gemini (Valid)')
             else:

vouchervision/LLM_GoogleGemini.py

@@ -7,6 +7,7 @@ from langchain.schema import HumanMessage
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import JsonOutputParser
 from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_google_vertexai import VertexAI
 
 from vouchervision.utils_LLM import SystemLoadMonitor, count_tokens
 from vouchervision.utils_LLM_JSON_validation import validate_and_align_JSON_keys_with_template
@@ -74,9 +75,13 @@ class GoogleGeminiHandler:
 
     def _build_model_chain_parser(self):
         # Instantiate the LLM class for Google Gemini
-        self.llm_model = ChatGoogleGenerativeAI(model='gemini-pro',
-                                    max_output_tokens=self.config.get('max_output_tokens'),
-                                    top_p=self.config.get('top_p'))    
+        # self.llm_model = ChatGoogleGenerativeAI(model='gemini-pro',
+        #                             max_output_tokens=self.config.get('max_output_tokens'),
+        #                             top_p=self.config.get('top_p'))    
+        self.llm_model = VertexAI(model='gemini-pro', 
+                                  max_output_tokens=self.config.get('max_output_tokens'),
+                                  top_p=self.config.get('top_p'))   
+        
         # Set up the retry parser with the runnable
         self.retry_parser = RetryWithErrorOutputParser.from_llm(parser=self.parser, llm=self.llm_model, max_retries=self.MAX_RETRIES)
         # Prepare the chain

vouchervision/LLM_GooglePalm2.py

@@ -9,6 +9,7 @@ from langchain.schema import HumanMessage
 from langchain.prompts import PromptTemplate
 from langchain_core.output_parsers import JsonOutputParser
 from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_google_vertexai import VertexAI
 
 from vouchervision.utils_LLM import SystemLoadMonitor, count_tokens
 from vouchervision.utils_LLM_JSON_validation import validate_and_align_JSON_keys_with_template
@@ -84,7 +85,8 @@ class GooglePalm2Handler:
 
     def _build_model_chain_parser(self):
         # Instantiate the parser and the retry parser
-        self.llm_model = ChatGoogleGenerativeAI(model=self.model_name)
+        # self.llm_model = ChatGoogleGenerativeAI(model=self.model_name)
+        self.llm_model = VertexAI(model=self.model_name)
         
         self.retry_parser = RetryWithErrorOutputParser.from_llm(
                                                 parser=self.parser,

vouchervision/OCR_google_cloud_vision.py

@@ -77,8 +77,8 @@ class OCRGoogle:
             self.client_beta = vision_beta.ImageAnnotatorClient(credentials=self.get_google_credentials())
             self.client = vision.ImageAnnotatorClient(credentials=self.get_google_credentials())
         else:
-            self.client_beta = vision_beta.ImageAnnotatorClient() 
-            self.client = vision.ImageAnnotatorClient()
+            self.client_beta = vision_beta.ImageAnnotatorClient(credentials=self.get_google_credentials()) 
+            self.client = vision.ImageAnnotatorClient(credentials=self.get_google_credentials())
 
 
     def get_google_credentials(self):
@@ -86,7 +86,7 @@ class OCRGoogle:
         credentials = service_account.Credentials.from_service_account_info(json.loads(creds_json_str))
         return credentials
     
-    
+
     def detect_text_with_trOCR_using_google_bboxes(self, do_use_trOCR, logger):
         CONFIDENCES = 0.80
         MAX_NEW_TOKENS = 50
@@ -517,6 +517,7 @@ class OCRGoogle:
 
         ### Optionally add trOCR to the self.OCR for additional context
         self.OCR = self.detect_text_with_trOCR_using_google_bboxes(self.do_use_trOCR, logger)
+        logger.info(f"OCR:\n{self.OCR}")
 
         if do_create_OCR_helper_image:
             self.image = Image.open(self.path)

vouchervision/utils_VoucherVision.py

@@ -72,14 +72,23 @@ class VoucherVision():
 
         self.catalog_name_options = ["Catalog Number", "catalog_number", "catalogNumber"]
 
-        self.utility_headers = ["filename",
-                                "WFO_override_OCR", "WFO_exact_match","WFO_exact_match_name","WFO_best_match","WFO_candidate_names","WFO_placement",
+        self.geo_headers = ["GEO_override_OCR", "GEO_method", "GEO_formatted_full_string", "GEO_decimal_lat",
+                       "GEO_decimal_long","GEO_city", "GEO_county", "GEO_state",
+                       "GEO_state_code", "GEO_country", "GEO_country_code", "GEO_continent",]
+        
+        self.wfo_headers = ["WFO_override_OCR", "WFO_exact_match","WFO_exact_match_name","WFO_best_match","WFO_candidate_names","WFO_placement"]
+        self.wfo_headers_no_lists = ["WFO_override_OCR", "WFO_exact_match","WFO_exact_match_name","WFO_best_match","WFO_placement"]
+        
+        self.utility_headers = ["filename"] + self.wfo_headers + self.geo_headers + ["tokens_in", "tokens_out", "path_to_crop","path_to_original","path_to_content","path_to_helper",]
+                                # "WFO_override_OCR", "WFO_exact_match","WFO_exact_match_name","WFO_best_match","WFO_candidate_names","WFO_placement",
                                 
-                                "GEO_override_OCR", "GEO_method", "GEO_formatted_full_string", "GEO_decimal_lat",
-                                "GEO_decimal_long","GEO_city", "GEO_county", "GEO_state",
-                                "GEO_state_code", "GEO_country", "GEO_country_code", "GEO_continent",
+                                # "GEO_override_OCR", "GEO_method", "GEO_formatted_full_string", "GEO_decimal_lat",
+                                # "GEO_decimal_long","GEO_city", "GEO_county", "GEO_state",
+                                # "GEO_state_code", "GEO_country", "GEO_country_code", "GEO_continent",
                                 
-                                "tokens_in", "tokens_out", "path_to_crop","path_to_original","path_to_content","path_to_helper",]
+                                # "tokens_in", "tokens_out", "path_to_crop","path_to_original","path_to_content","path_to_helper",]
+        
+        # WFO_candidate_names is separate, bc it may be type --> list
 
         self.do_create_OCR_helper_image = self.cfg['leafmachine']['do_create_OCR_helper_image']
 
@@ -100,6 +109,7 @@ class VoucherVision():
         self.logger.info(f'     Model name passed to API --> {self.model_name}')
         self.logger.info(f'     API access token is found in PRIVATE_DATA.yaml --> {self.has_key}')
 
+
     def init_trOCR_model(self):
         lgr = logging.getLogger('transformers')
         lgr.setLevel(logging.ERROR)
@@ -111,13 +121,14 @@ class VoucherVision():
         self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
         self.trOCR_model.to(self.device)
 
+
     def map_API_options(self):
         self.chat_version = self.cfg['leafmachine']['LLM_version']
 
         # Get the required values from ModelMaps
         self.model_name = ModelMaps.get_version_mapping_cost(self.chat_version)
         self.is_azure = ModelMaps.get_version_mapping_is_azure(self.chat_version)
-        self.has_key = ModelMaps.get_version_has_key(self.chat_version, self.has_key_openai, self.has_key_azure_openai, self.has_key_palm2, self.has_key_mistral)
+        self.has_key = ModelMaps.get_version_has_key(self.chat_version, self.has_key_openai, self.has_key_azure_openai, self.has_key_google_application_credentials, self.has_key_mistral)
 
         # Check if the version is supported
         if self.model_name is None:
@@ -126,28 +137,18 @@ class VoucherVision():
 
         self.version_name = self.chat_version
 
+
     def map_prompt_versions(self):
         self.prompt_version_map = {
             "Version 1": "prompt_v1_verbose",
-            "Version 1 No Domain Knowledge": "prompt_v1_verbose_noDomainKnowledge",
-            "Version 2": "prompt_v2_json_rules",
-            "Version 1 PaLM 2": 'prompt_v1_palm2',
-            "Version 1 PaLM 2 No Domain Knowledge": 'prompt_v1_palm2_noDomainKnowledge', 
-            "Version 2 PaLM 2": 'prompt_v2_palm2',
         }
         self.prompt_version = self.prompt_version_map.get(self.prompt_version0, self.path_custom_prompts)
         self.is_predefined_prompt = self.is_in_prompt_version_map(self.prompt_version)
 
+
     def is_in_prompt_version_map(self, value):
         return value in self.prompt_version_map.values()
 
-    # def init_embeddings(self):
-    #     if self.use_domain_knowledge:
-    #         self.logger.info(f'*** USING DOMAIN KNOWLEDGE ***')
-    #         self.logger.info(f'*** Initializing vector embeddings database ***')
-    #         self.initialize_embeddings()
-    #     else:
-    #         self.Voucher_Vision_Embedding = None
 
     def map_dir_labels(self):
         if self.cfg['leafmachine']['use_RGB_label_images']:
@@ -158,6 +159,7 @@ class VoucherVision():
         # Use glob to get all image paths in the directory
         self.img_paths = glob.glob(os.path.join(self.dir_labels, "*"))
 
+
     def load_rules_config(self):
         with open(self.path_custom_prompts, 'r') as stream:
             try:
@@ -166,6 +168,7 @@ class VoucherVision():
                 print(exc)
                 return None
             
+
     def generate_xlsx_headers(self):
         # Extract headers from the 'Dictionary' keys in the JSON template rules
         # xlsx_headers = list(self.rules_config_json['rules']["Dictionary"].keys())
@@ -173,21 +176,10 @@ class VoucherVision():
         xlsx_headers = xlsx_headers + self.utility_headers
         return xlsx_headers
 
+
     def init_transcription_xlsx(self):
-        # self.HEADERS_v1_n22 = ["Catalog Number","Genus","Species","subspecies","variety","forma","Country","State","County","Locality Name","Min Elevation","Max Elevation","Elevation Units","Verbatim Coordinates","Datum","Cultivated","Habitat","Collectors","Collector Number","Verbatim Date","Date","End Date"] 
-        # self.HEADERS_v2_n26 = ["catalog_number","genus","species","subspecies","variety","forma","country","state","county","locality_name","min_elevation","max_elevation","elevation_units","verbatim_coordinates","decimal_coordinates","datum","cultivated","habitat","plant_description","collectors","collector_number","determined_by","multiple_names","verbatim_date","date","end_date"]
-        # self.HEADERS_v1_n22 = self.HEADERS_v1_n22 + self.utility_headers
-        # self.HEADERS_v2_n26 = self.HEADERS_v2_n26 + self.utility_headers
         # Initialize output file
         self.path_transcription = os.path.join(self.Dirs.transcription,"transcribed.xlsx")
-
-        # if self.prompt_version in ['prompt_v2_json_rules','prompt_v2_palm2']:
-            # self.headers = self.HEADERS_v2_n26
-            # self.headers_used = 'HEADERS_v2_n26'
-        
-        # elif self.prompt_version in ['prompt_v1_verbose', 'prompt_v1_verbose_noDomainKnowledge','prompt_v1_palm2', 'prompt_v1_palm2_noDomainKnowledge']:
-            # self.headers = self.HEADERS_v1_n22
-            # self.headers_used = 'HEADERS_v1_n22'
         
         # else:
         if not self.is_predefined_prompt:
@@ -223,7 +215,6 @@ class VoucherVision():
             except ValueError:
                 print("'path_to_crop' not found in the header row.")
 
-            
             path_to_crop = list(sheet.iter_cols(min_col=path_to_crop_col, max_col=path_to_crop_col, values_only=True, min_row=2))
             path_to_original = list(sheet.iter_cols(min_col=path_to_original_col, max_col=path_to_original_col, values_only=True, min_row=2))
             path_to_content = list(sheet.iter_cols(min_col=path_to_content_col, max_col=path_to_content_col, values_only=True, min_row=2))
@@ -303,14 +294,8 @@ class VoucherVision():
                     break
 
 
-
     def add_data_to_excel_from_response(self, path_transcription, response, WFO_record, GEO_record, filename_without_extension, path_to_crop, path_to_content, path_to_helper, nt_in, nt_out):
-        geo_headers = ["GEO_override_OCR", "GEO_method", "GEO_formatted_full_string", "GEO_decimal_lat",
-                       "GEO_decimal_long","GEO_city", "GEO_county", "GEO_state",
-                       "GEO_state_code", "GEO_country", "GEO_country_code", "GEO_continent",]
         
-        # WFO_candidate_names is separate, bc it may be type --> list
-        wfo_headers = ["WFO_override_OCR", "WFO_exact_match","WFO_exact_match_name","WFO_best_match","WFO_placement"]
 
         wb = openpyxl.load_workbook(path_transcription)
         sheet = wb.active
@@ -376,7 +361,7 @@ class VoucherVision():
                 sheet.cell(row=next_row, column=i, value=filename_without_extension)
 
             # "WFO_exact_match","WFO_exact_match_name","WFO_best_match","WFO_candidate_names","WFO_placement"
-            elif header.value in wfo_headers:
+            elif header.value in self.wfo_headers_no_lists:
                 sheet.cell(row=next_row, column=i, value=WFO_record.get(header.value, ''))
             # elif header.value == "WFO_exact_match":
             #     sheet.cell(row=next_row, column=i, value= WFO_record.get("WFO_exact_match",''))
@@ -397,7 +382,7 @@ class VoucherVision():
             
             # "GEO_method", "GEO_formatted_full_string", "GEO_decimal_lat", "GEO_decimal_long",
             # "GEO_city", "GEO_county", "GEO_state", "GEO_state_code", "GEO_country", "GEO_country_code", "GEO_continent"
-            elif header.value in geo_headers:
+            elif header.value in self.geo_headers:
                 sheet.cell(row=next_row, column=i, value=GEO_record.get(header.value, ''))
 
         # save the workbook
@@ -447,7 +432,7 @@ class VoucherVision():
             self.cfg_private = get_cfg_from_full_path(self.path_cfg_private)
 
             k_openai = self.cfg_private['openai']['OPENAI_API_KEY']
-            k_openai_azure = self.cfg_private['openai_azure']['OPENAI_API_VERSION']
+            k_openai_azure = self.cfg_private['openai_azure']['OPENAI_API_KEY_AZURE']
 
             k_google_project_id = self.cfg_private['google']['GOOGLE_PROJECT_ID']
             k_google_location = self.cfg_private['google']['GOOGLE_LOCATION']
@@ -505,7 +490,7 @@ class VoucherVision():
                 self.llm = AzureChatOpenAI(
                     deployment_name = 'gpt-35-turbo',#'gpt-35-turbo',
                     openai_api_version = self.cfg_private['openai_azure']['OPENAI_API_VERSION'],
-                    openai_api_key = self.cfg_private['openai_azure']['OPENAI_API_KEY'],
+                    openai_api_key = self.cfg_private['openai_azure']['OPENAI_API_KEY_AZURE'],
                     azure_endpoint = self.cfg_private['openai_azure']['OPENAI_API_BASE'],
                     openai_organization = self.cfg_private['openai_azure']['OPENAI_ORGANIZATION'],
                 )

vouchervision/utils_hf.py

@@ -42,15 +42,44 @@ def save_uploaded_file(directory, img_file, image=None):
         os.makedirs(directory)
     # Assuming the uploaded file is an image
     if image is None:
-        with Image.open(img_file) as image:
+        try:
+            with Image.open(img_file) as image:
+                full_path = os.path.join(directory, img_file.name)
+                image.save(full_path, "JPEG")
+            # Return the full path of the saved image
+            return full_path
+        except:
+            with Image.open(os.path.join(directory,img_file)) as image:
+                full_path = os.path.join(directory, img_file)
+                image.save(full_path, "JPEG")
+            # Return the full path of the saved image
+            return full_path
+    else:
+        try:
             full_path = os.path.join(directory, img_file.name)
             image.save(full_path, "JPEG")
+            return full_path
+        except:
+            full_path = os.path.join(directory, img_file)
+            image.save(full_path, "JPEG")
+            return full_path
+    
+def save_uploaded_local(directory, img_file, image=None):
+    name = img_file.split(os.path.sep)[-1]
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+    
+    # Assuming the uploaded file is an image
+    if image is None:
+        with Image.open(img_file) as image:
+            full_path = os.path.join(directory, name)
+            image.save(full_path, "JPEG")
         # Return the full path of the saved image
-        return full_path
+        return os.path.join('uploads_small',name)
     else:
-        full_path = os.path.join(directory, img_file.name)
+        full_path = os.path.join(directory, name)
         image.save(full_path, "JPEG")
-        return full_path
+        return os.path.join('.','uploads_small',name)
     
 def image_to_base64(img):
     buffered = BytesIO()