vouchervision/utils_VoucherVision.py

import openai
import os, sys, json, inspect, glob, tiktoken, shutil, yaml
import openpyxl
from openpyxl import Workbook, load_workbook
import google.generativeai as palm
from langchain.chat_models import AzureChatOpenAI
from google.oauth2 import service_account

currentdir = os.path.dirname(os.path.abspath(
    inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)
parentdir = os.path.dirname(parentdir)
sys.path.append(parentdir)

from general_utils import get_cfg_from_full_path, num_tokens_from_string
from embeddings_db import VoucherVisionEmbedding
from OCR_google_cloud_vision import detect_text, overlay_boxes_on_image
from LLM_chatGPT_3_5 import OCR_to_dict, OCR_to_dict_16k
from LLM_PaLM import OCR_to_dict_PaLM
# from LLM_Falcon import OCR_to_dict_Falcon
from prompts import PROMPT_UMICH_skeleton_all_asia, PROMPT_OCR_Organized, PROMPT_UMICH_skeleton_all_asia_GPT4, PROMPT_OCR_Organized_GPT4, PROMPT_JSON
from prompt_catalog import PromptCatalog
'''
* For the prefix_removal, the image names have 'MICH-V-' prior to the barcode, so that is used for matching
  but removed for output.
* There is also code active to replace the LLM-predicted "Catalog Number" with the correct number since it is known.
  The LLMs to usually assign the barcode to the correct field, but it's not needed since it is already known.
        - Look for ####################### Catalog Number pre-defined
'''

'''
Prior to StructuredOutputParser:
    response = openai.ChatCompletion.create(
            model=MODEL,
            temperature = 0,
            messages=[
                {"role": "system", "content": "You are a helpful assistant acting as a transcription expert and your job is to transcribe herbarium specimen labels based on OCR data and reformat it to meet Darwin Core Archive Standards into a Python dictionary based on certain rules."},
                {"role": "user", "content": prompt},
            ],
            max_tokens=2048,
        )
        # print the model's response
        return response.choices[0].message['content']
'''

class VoucherVision():

    def __init__(self, cfg, logger, dir_home, path_custom_prompts, Project, Dirs):
        self.cfg = cfg
        self.logger = logger
        self.dir_home = dir_home
        self.path_custom_prompts = path_custom_prompts
        self.Project = Project
        self.Dirs = Dirs
        self.headers = None
        self.prompt_version = None
        self.client = None

        self.set_API_keys()
        self.setup()


    def setup(self):
        self.logger.name = f'[Transcription]'
        self.logger.info(f'Setting up OCR and LLM')

        self.db_name = self.cfg['leafmachine']['project']['embeddings_database_name']
        self.path_domain_knowledge = self.cfg['leafmachine']['project']['path_to_domain_knowledge_xlsx']
        self.build_new_db = self.cfg['leafmachine']['project']['build_new_embeddings_database']

        self.continue_run_from_partial_xlsx = self.cfg['leafmachine']['project']['continue_run_from_partial_xlsx']

        self.prefix_removal = self.cfg['leafmachine']['project']['prefix_removal']
        self.suffix_removal = self.cfg['leafmachine']['project']['suffix_removal']
        self.catalog_numerical_only = self.cfg['leafmachine']['project']['catalog_numerical_only']

        self.prompt_version0 = self.cfg['leafmachine']['project']['prompt_version']
        self.use_domain_knowledge = self.cfg['leafmachine']['project']['use_domain_knowledge']

        self.catalog_name_options = ["Catalog Number", "catalog_number"]

        self.utility_headers = ["tokens_in", "tokens_out", "path_to_crop","path_to_original","path_to_content","path_to_helper",]

        self.map_prompt_versions()
        self.map_dir_labels()
        self.map_API_options()
        self.init_embeddings()
        self.init_transcription_xlsx()

        '''Logging'''
        self.logger.info(f'Transcribing dataset --- {self.dir_labels}')
        self.logger.info(f'Saving transcription batch to --- {self.path_transcription}')
        self.logger.info(f'Saving individual transcription files to --- {self.Dirs.transcription_ind}')
        self.logger.info(f'Starting transcription...')
        self.logger.info(f'     LLM MODEL --> {self.version_name}')
        self.logger.info(f'     Using Azure API --> {self.is_azure}')
        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 map_API_options(self):
    #     self.chat_version = self.cfg['leafmachine']['LLM_version']
    #     version_mapping = {
    #         'GPT 4': ('OpenAI GPT 4', False, 'GPT_4', self.has_key_openai),
    #         'GPT 3.5': ('OpenAI GPT 3.5', False, 'GPT_3_5', self.has_key_openai),
    #         'Azure GPT 3.5': ('(Azure) OpenAI GPT 3.5', True, 'Azure_GPT_3_5', self.has_key_azure_openai),
    #         'Azure GPT 4': ('(Azure) OpenAI GPT 4', True, 'Azure_GPT_4', self.has_key_azure_openai),
    #         'PaLM 2': ('Google PaLM 2', None, None, self.has_key_palm2)
    #     }
    #     if self.chat_version not in version_mapping:
    #         supported_LLMs = ", ".join(version_mapping.keys())
    #         raise Exception(f"Unsupported LLM: {self.chat_version}. Requires one of: {supported_LLMs}")

    #     self.version_name, self.is_azure, self.model_name, self.has_key = version_mapping[self.chat_version]
    def map_API_options(self):
        self.chat_version = self.cfg['leafmachine']['LLM_version']  # Replace with your env variable for LLM version if needed

        # Assuming you have set your environment variables for each key like 'OPENAI_API_KEY', 'AZURE_API_KEY', 'PALM_API_KEY'
        openai_api_key = os.getenv('OPENAI_API_KEY')
        azure_api_key = os.getenv('AZURE_API_KEY')
        palm_api_key = os.getenv('PALM_API_KEY')

        version_mapping = {
            'GPT 4': ('OpenAI GPT 4', False, 'GPT_4', bool(openai_api_key)),
            'GPT 3.5': ('OpenAI GPT 3.5', False, 'GPT_3_5', bool(openai_api_key)),
            'Azure GPT 3.5': ('(Azure) OpenAI GPT 3.5', True, 'Azure_GPT_3_5', bool(azure_api_key)),
            'Azure GPT 4': ('(Azure) OpenAI GPT 4', True, 'Azure_GPT_4', bool(azure_api_key)),
            'PaLM 2': ('Google PaLM 2', None, None, bool(palm_api_key))
        }

        if self.chat_version not in version_mapping:
            supported_llms = ", ".join(version_mapping.keys())
            raise Exception(f"Unsupported LLM: {self.chat_version}. Requires one of: {supported_llms}")

        self.version_name, self.is_azure, self.model_name, self.has_key = version_mapping[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']:
            self.dir_labels = os.path.join(self.Dirs.save_per_annotation_class,'label')
        else:
            self.dir_labels = self.Dirs.save_original

        # 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:
                return yaml.safe_load(stream)
            except yaml.YAMLError as exc:
                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())
        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:
                # Load the rules configuration
                self.rules_config_json = self.load_rules_config()
                # Generate the headers from the configuration
                self.headers = self.generate_xlsx_headers()
                # Set the headers used to the dynamically generated headers
                self.headers_used = 'CUSTOM'
            else:
                # If it's a predefined prompt, raise an exception as we don't have further instructions
                raise ValueError("Predefined prompt is not handled in this context.")

        self.create_or_load_excel_with_headers(os.path.join(self.Dirs.transcription,"transcribed.xlsx"), self.headers)


    def pick_model(self, vendor, nt):
        if vendor == 'GPT_3_5':
            if nt > 6000:
                return "gpt-3.5-turbo-16k-0613", True
            else:
                return "gpt-3.5-turbo", False
        if vendor == 'GPT_4':
            return "gpt-4", False
        if vendor == 'Azure_GPT_3_5':
            return "gpt-35-turbo", False
        if vendor == 'Azure_GPT_4':
            return "gpt-4", False
           
    def create_or_load_excel_with_headers(self, file_path, headers, show_head=False):
        output_dir_names = ['Archival_Components', 'Config_File', 'Cropped_Images', 'Logs', 'Original_Images', 'Transcription']
        self.completed_specimens = []

        # Check if the file exists and it's not None
        if self.continue_run_from_partial_xlsx is not None and os.path.isfile(self.continue_run_from_partial_xlsx):
            workbook = load_workbook(filename=self.continue_run_from_partial_xlsx)
            sheet = workbook.active
            show_head=True
            # Identify the 'path_to_crop' column
            try:
                path_to_crop_col = headers.index('path_to_crop') + 1
                path_to_original_col = headers.index('path_to_original') + 1
                path_to_content_col = headers.index('path_to_content') + 1
                path_to_helper_col = headers.index('path_to_helper') + 1
                # self.completed_specimens = list(sheet.iter_cols(min_col=path_to_crop_col, max_col=path_to_crop_col, values_only=True, min_row=2))
            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))
            path_to_helper = list(sheet.iter_cols(min_col=path_to_helper_col, max_col=path_to_helper_col, values_only=True, min_row=2))
            others = [path_to_crop_col, path_to_original_col, path_to_content_col, path_to_helper_col]
            jsons = [path_to_content_col, path_to_helper_col]

            for cell in path_to_crop[0]:
                old_path = cell
                new_path = file_path
                for dir_name in output_dir_names:
                    if dir_name in old_path:
                        old_path_parts = old_path.split(dir_name)
                        new_path_parts = new_path.split('Transcription')
                        updated_path = new_path_parts[0] + dir_name + old_path_parts[1]
                        self.completed_specimens.append(os.path.basename(updated_path))
            print(f"{len(self.completed_specimens)} images are already completed")

            ### Copy the JSON files over
            for colu in jsons:
                cell = next(sheet.iter_rows(min_row=2, min_col=colu, max_col=colu))[0]
                old_path = cell.value
                new_path = file_path

                old_path_parts = old_path.split('Transcription')
                new_path_parts = new_path.split('Transcription')
                updated_path = new_path_parts[0] + 'Transcription' + old_path_parts[1]

                # Copy files
                old_dir = os.path.dirname(old_path)
                new_dir = os.path.dirname(updated_path)

                # Check if old_dir exists and it's a directory
                if os.path.exists(old_dir) and os.path.isdir(old_dir):
                    # Check if new_dir exists. If not, create it.
                    if not os.path.exists(new_dir):
                        os.makedirs(new_dir)

                    # Iterate through all files in old_dir and copy each to new_dir
                    for filename in os.listdir(old_dir):
                        shutil.copy2(os.path.join(old_dir, filename), new_dir) # copy2 preserves metadata

            ### Update the file names
            for colu in others:
                for row in sheet.iter_rows(min_row=2, min_col=colu, max_col=colu):
                    for cell in row:
                        old_path = cell.value
                        new_path = file_path
                        for dir_name in output_dir_names:
                            if dir_name in old_path:
                                old_path_parts = old_path.split(dir_name)
                                new_path_parts = new_path.split('Transcription')
                                updated_path = new_path_parts[0] + dir_name + old_path_parts[1]
                                cell.value = updated_path
            show_head=True

                
        else:
            # Create a new workbook and select the active worksheet
            workbook = Workbook()
            sheet = workbook.active

            # Write headers in the first row
            for i, header in enumerate(headers, start=1):
                sheet.cell(row=1, column=i, value=header)
            self.completed_specimens = []
            
        # Save the workbook
        workbook.save(file_path)

        if show_head:
            print("continue_run_from_partial_xlsx:")
            for i, row in enumerate(sheet.iter_rows(values_only=True)):
                print(row)
                if i == 3:  # print the first 5 rows (0-indexed)
                    print("\n")
                    break



    def add_data_to_excel_from_response(self, path_transcription, response, filename_without_extension, path_to_crop, path_to_content, path_to_helper, nt_in, nt_out):
        wb = openpyxl.load_workbook(path_transcription)
        sheet = wb.active

        # find the next empty row
        next_row = sheet.max_row + 1

        if isinstance(response, str):
            try:
                response = json.loads(response)
            except json.JSONDecodeError:
                print(f"Failed to parse response: {response}")
                return

        # iterate over headers in the first row
        for i, header in enumerate(sheet[1], start=1):
            # check if header value is in response keys
            if (header.value in response) and (header.value not in self.catalog_name_options): ####################### Catalog Number pre-defined
                # check if the response value is a dictionary
                if isinstance(response[header.value], dict):
                    # if it is a dictionary, extract the 'value' field
                    cell_value = response[header.value].get('value', '')
                else:
                    # if it's not a dictionary, use it directly
                    cell_value = response[header.value]
                
                try:
                    # write the value to the cell
                    sheet.cell(row=next_row, column=i, value=cell_value)
                except:
                    sheet.cell(row=next_row, column=i, value=cell_value[0])

            elif header.value in self.catalog_name_options: 
                # if self.prefix_removal:
                #     filename_without_extension = filename_without_extension.replace(self.prefix_removal, "")
                # if self.suffix_removal:
                #     filename_without_extension = filename_without_extension.replace(self.suffix_removal, "")
                # if self.catalog_numerical_only:
                #     filename_without_extension = self.remove_non_numbers(filename_without_extension)
                sheet.cell(row=next_row, column=i, value=filename_without_extension)
            elif header.value == "path_to_crop":
                sheet.cell(row=next_row, column=i, value=path_to_crop)
            elif header.value == "path_to_original":
                if self.cfg['leafmachine']['use_RGB_label_images']:
                    fname = os.path.basename(path_to_crop)
                    base = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(path_to_crop))))
                    path_to_original = os.path.join(base, 'Original_Images', fname)
                    sheet.cell(row=next_row, column=i, value=path_to_original)
                else:
                    fname = os.path.basename(path_to_crop)
                    base = os.path.dirname(os.path.dirname(path_to_crop))
                    path_to_original = os.path.join(base, 'Original_Images', fname)
                    sheet.cell(row=next_row, column=i, value=path_to_original)
            elif header.value == "path_to_content":
                sheet.cell(row=next_row, column=i, value=path_to_content)
            elif header.value == "path_to_helper":
                sheet.cell(row=next_row, column=i, value=path_to_helper)
            elif header.value == "tokens_in":
                sheet.cell(row=next_row, column=i, value=nt_in)
            elif header.value == "tokens_out":
                sheet.cell(row=next_row, column=i, value=nt_out)
        # save the workbook
        wb.save(path_transcription)

    def configure_azure_llm(self):
        # Access the secrets from the environment
        azure_api_version = os.getenv('AZURE_API_VERSION')
        azure_api_key = os.getenv('AZURE_API_KEY')
        azure_api_base = os.getenv('AZURE_API_BASE')
        azure_organization = os.getenv('AZURE_ORGANIZATION')
        azure_api_type = os.getenv('AZURE_API_TYPE')
        azure_deployment_name = os.getenv('AZURE_DEPLOYMENT_NAME')

        # Check if all required Azure configurations are present
        if azure_api_version and azure_api_key and azure_api_base and azure_organization and azure_api_type and azure_deployment_name:
            self.llm = AzureChatOpenAI(
                deployment_name=azure_deployment_name,
                openai_api_version=azure_api_version,
                openai_api_key=azure_api_key,
                openai_api_base=azure_api_base,
                openai_organization=azure_organization,
                openai_api_type=azure_api_type
            )
        else:
            raise ValueError("Missing Azure configuration in environment variables.")

    def set_API_keys(self):
        # Access secrets directly from the environment
        openai_api_key = os.getenv('OPENAI_API_KEY')
        google_application_credentials = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
        palm_api_key = os.getenv('PALM_API_KEY')

        self.has_key_openai = openai_api_key is not None
        self.has_key_google_OCR = google_application_credentials is not None
        self.has_key_palm2 = palm_api_key is not None

        if self.has_key_google_OCR:
            # Get the credentials JSON from the environment variable
            google_credentials_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
            # Convert the JSON string into a Python dictionary
            google_credentials_dict = json.loads(google_credentials_json)
            # Create a credentials object
            google_credentials = service_account.Credentials.from_service_account_info(google_credentials_dict)

            # Now, use this `google_credentials` object to authenticate your Google Cloud services
            # For example, if you are using the Google Vision API, it would look like this:
            from google.cloud import vision
            self.client = vision.ImageAnnotatorClient(credentials=google_credentials)

        if os.getenv('AZURE_API_KEY') is not None:
            self.configure_azure_llm()

        if self.has_key_palm2:
            palm.configure(api_key=palm_api_key)

        if self.has_key_openai:
            openai.api_key = openai_api_key
            os.environ["OPENAI_API_KEY"] = openai_api_key
        

    def initialize_embeddings(self):
        '''Loading embedding search       __init__(self, db_name, path_domain_knowledge, logger, build_new_db=False, model_name="hkunlp/instructor-xl", device="cuda")'''
        self.Voucher_Vision_Embedding = VoucherVisionEmbedding(self.db_name, self.path_domain_knowledge, logger=self.logger, build_new_db=self.build_new_db)

    def clean_catalog_number(self, data, filename_without_extension):
        #Cleans up the catalog number in data if it's a dict
        
        def modify_catalog_key(catalog_key, filename_without_extension, data):
            # Helper function to apply modifications on catalog number
            if catalog_key not in data:
                new_data = {catalog_key: None}
                data = {**new_data, **data}

            if self.prefix_removal:
                filename_without_extension = filename_without_extension.replace(self.prefix_removal, "")
            if self.suffix_removal:
                filename_without_extension = filename_without_extension.replace(self.suffix_removal, "")
            if self.catalog_numerical_only:
                filename_without_extension = self.remove_non_numbers(data[catalog_key])
            data[catalog_key] = filename_without_extension
            return data
        
        if isinstance(data, dict):
            if self.headers_used == 'HEADERS_v1_n22':
                return modify_catalog_key("Catalog Number", filename_without_extension, data)
            elif self.headers_used in ['HEADERS_v2_n26', 'CUSTOM']:
                return modify_catalog_key("catalog_number", filename_without_extension, data)
            else:
                raise ValueError("Invalid headers used.")
        else:
            raise TypeError("Data is not of type dict.")
        

    def write_json_to_file(self, filepath, data):
        '''Writes dictionary data to a JSON file.'''
        with open(filepath, 'w') as txt_file:
            if isinstance(data, dict):
                data = json.dumps(data, indent=4)
            txt_file.write(data)

    def create_null_json(self):
        return {}
    
    def remove_non_numbers(self, s):
        return ''.join([char for char in s if char.isdigit()])
    
    def create_null_row(self, filename_without_extension, path_to_crop, path_to_content, path_to_helper):
        json_dict = {header: '' for header in self.headers} 
        for header, value in json_dict.items():
            if header in self.catalog_name_options:
                if self.prefix_removal:
                    json_dict[header] = filename_without_extension.replace(self.prefix_removal, "")
                if self.suffix_removal:
                    json_dict[header] = filename_without_extension.replace(self.suffix_removal, "")
                if self.catalog_numerical_only:
                    json_dict[header] = self.remove_non_numbers(json_dict[header])
            elif header == "path_to_crop":
                json_dict[header] = path_to_crop
            elif header == "path_to_original":
                fname = os.path.basename(path_to_crop)
                base = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(path_to_crop))))
                path_to_original = os.path.join(base, 'Original_Images', fname)
                json_dict[header] = path_to_original
            elif header == "path_to_content":
                json_dict[header] = path_to_content
            elif header == "path_to_helper":
                json_dict[header] = path_to_helper
        return json_dict


    def setup_GPT(self, prompt_version, gpt):
        Catalog = PromptCatalog()
        self.logger.info(f'Length of OCR raw -- {len(self.OCR)}')

        # if prompt_version == 'prompt_v1_verbose':
        if self.is_predefined_prompt:
            if self.use_domain_knowledge:
                # Find a similar example from the domain knowledge
                domain_knowledge_example = self.Voucher_Vision_Embedding.query_db(self.OCR, 1)
                similarity= self.Voucher_Vision_Embedding.get_similarity()

                if prompt_version == 'prompt_v1_verbose':
                    prompt, n_fields, xlsx_headers = Catalog.prompt_v1_verbose(OCR=self.OCR,domain_knowledge_example=domain_knowledge_example,similarity=similarity)

            else:
                if prompt_version == 'prompt_v1_verbose_noDomainKnowledge':
                    prompt, n_fields, xlsx_headers = Catalog.prompt_v1_verbose_noDomainKnowledge(OCR=self.OCR)

                elif prompt_version ==  'prompt_v2_json_rules':
                    prompt, n_fields, xlsx_headers = Catalog.prompt_v2_json_rules(OCR=self.OCR)
        else:
            prompt, n_fields, xlsx_headers = Catalog.prompt_v2_custom(self.path_custom_prompts, OCR=self.OCR)
            


        nt = num_tokens_from_string(prompt, "cl100k_base")
        self.logger.info(f'Prompt token length --- {nt}')

        MODEL, use_long_form = self.pick_model(gpt, nt)
        self.logger.info(f'Waiting for {gpt} API call --- Using {MODEL}')

        return MODEL, prompt, use_long_form, n_fields, xlsx_headers, nt

        
    # def setup_GPT(self, opt, gpt):
    #     if opt == 'dict':
    #         # Find a similar example from the domain knowledge
    #         domain_knowledge_example = self.Voucher_Vision_Embedding.query_db(self.OCR, 1)
    #         similarity= self.Voucher_Vision_Embedding.get_similarity()

    #         self.logger.info(f'Length of OCR raw -- {len(self.OCR)}')

    #         # prompt = PROMPT_UMICH_skeleton_all_asia_GPT4(self.OCR, domain_knowledge_example, similarity)
    #         prompt, n_fields, xlsx_headers = 

    #         nt = num_tokens_from_string(prompt, "cl100k_base")
    #         self.logger.info(f'Prompt token length --- {nt}')

    #         MODEL, use_long_form = self.pick_model(gpt, nt)

    #         ### Direct GPT ###
    #         self.logger.info(f'Waiting for {MODEL} API call --- Using chatGPT --- Content')

    #         return MODEL, prompt, use_long_form
        
    #     elif opt == 'helper':
    #         prompt = PROMPT_OCR_Organized_GPT4(self.OCR)
    #         nt = num_tokens_from_string(prompt, "cl100k_base")

    #         MODEL, use_long_form = self.pick_model(gpt, nt)

    #         self.logger.info(f'Length of OCR raw -- {len(self.OCR)}')
    #         self.logger.info(f'Prompt token length --- {nt}')
    #         self.logger.info(f'Waiting for {MODEL} API call --- Using chatGPT --- Helper')

    #         return MODEL, prompt, use_long_form


    def use_chatGPT(self, is_azure, progress_report, gpt):
        total_tokens_in = 0
        total_tokens_out = 0
        final_JSON_response = None
        if progress_report is not None:
            progress_report.set_n_batches(len(self.img_paths))
        for i, path_to_crop in enumerate(self.img_paths):
            if progress_report is not None:
                progress_report.update_batch(f"Working on image {i+1} of {len(self.img_paths)}")

            if os.path.basename(path_to_crop) in self.completed_specimens:
                self.logger.info(f'[Skipping] specimen {os.path.basename(path_to_crop)} already processed')
            else:
                filename_without_extension, txt_file_path, txt_file_path_OCR, txt_file_path_OCR_bounds, jpg_file_path_OCR_helper = self.generate_paths(path_to_crop, i)

                # Use Google Vision API to get OCR
                # self.OCR = detect_text(path_to_crop) 
                self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Starting OCR')
                self.OCR, self.bounds, self.text_to_box_mapping = detect_text(path_to_crop, self.client)
                self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Finished OCR')
                if len(self.OCR) > 0:
                    self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Creating OCR Overlay Image')
                    self.overlay_image = overlay_boxes_on_image(path_to_crop, self.bounds, self.cfg['leafmachine']['do_create_OCR_helper_image'])
                    self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Saved OCR Overlay Image')
                    
                    self.write_json_to_file(txt_file_path_OCR, {"OCR":self.OCR})
                    self.write_json_to_file(txt_file_path_OCR_bounds, {"OCR_Bounds":self.bounds})
                    self.overlay_image.save(jpg_file_path_OCR_helper)

                    # Setup Dict
                    MODEL, prompt, use_long_form, n_fields, xlsx_headers, nt_in = self.setup_GPT(self.prompt_version, gpt)

                    if is_azure:
                        self.llm.deployment_name = MODEL
                    else:
                        self.llm = None

                    # Send OCR to chatGPT and return formatted dictonary
                    if use_long_form:
                        response_candidate = OCR_to_dict_16k(is_azure, self.logger, MODEL, prompt, self.llm, self.prompt_version) 
                        nt_out = num_tokens_from_string(response_candidate, "cl100k_base")
                    else:
                        response_candidate = OCR_to_dict(is_azure, self.logger, MODEL, prompt, self.llm, self.prompt_version)
                        nt_out = num_tokens_from_string(response_candidate, "cl100k_base")
                else: 
                    response_candidate = None
                    nt_out = 0

                total_tokens_in += nt_in
                total_tokens_out += nt_out

                final_JSON_response0 = self.save_json_and_xlsx(response_candidate, filename_without_extension, path_to_crop, txt_file_path, jpg_file_path_OCR_helper, nt_in, nt_out)
                if response_candidate is not None:
                    final_JSON_response = final_JSON_response0

                self.logger.info(f'Formatted JSON\n{final_JSON_response}')
                self.logger.info(f'Finished {MODEL} API calls\n')
        
        if progress_report is not None:
            progress_report.reset_batch(f"Batch Complete")
        try:
            final_JSON_response = json.loads(final_JSON_response.strip('```').replace('json\n', '', 1).replace('json', '', 1))
        except:
            pass
        return final_JSON_response, total_tokens_in, total_tokens_out

                    

    def use_PaLM(self, progress_report):
        total_tokens_in = 0
        total_tokens_out = 0
        final_JSON_response = None
        if progress_report is not None:
            progress_report.set_n_batches(len(self.img_paths))
        for i, path_to_crop in enumerate(self.img_paths):
            if progress_report is not None:
                progress_report.update_batch(f"Working on image {i+1} of {len(self.img_paths)}")
            if os.path.basename(path_to_crop) in self.completed_specimens:
                self.logger.info(f'[Skipping] specimen {os.path.basename(path_to_crop)} already processed')
            else:
                filename_without_extension, txt_file_path, txt_file_path_OCR, txt_file_path_OCR_bounds, jpg_file_path_OCR_helper = self.generate_paths(path_to_crop, i)
                
                # Use Google Vision API to get OCR
                self.OCR, self.bounds, self.text_to_box_mapping = detect_text(path_to_crop, self.client)
                if len(self.OCR) > 0:
                    self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Starting OCR')
                    self.OCR = self.OCR.replace("\'", "Minutes").replace('\"', "Seconds")
                    self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Finished OCR')

                    self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Creating OCR Overlay Image')
                    self.overlay_image = overlay_boxes_on_image(path_to_crop, self.bounds, self.cfg['leafmachine']['do_create_OCR_helper_image'])
                    self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- Saved OCR Overlay Image')
                    
                    self.write_json_to_file(txt_file_path_OCR, {"OCR":self.OCR})
                    self.write_json_to_file(txt_file_path_OCR_bounds, {"OCR_Bounds":self.bounds})
                    self.overlay_image.save(jpg_file_path_OCR_helper)

                    # Send OCR to chatGPT and return formatted dictonary
                    response_candidate, nt_in = OCR_to_dict_PaLM(self.logger, self.OCR, self.prompt_version, self.Voucher_Vision_Embedding)
                    nt_out = num_tokens_from_string(response_candidate, "cl100k_base")
                    
                else:
                    response_candidate = None
                    nt_out = 0

                total_tokens_in += nt_in
                total_tokens_out += nt_out

                final_JSON_response0 = self.save_json_and_xlsx(response_candidate, filename_without_extension, path_to_crop, txt_file_path, jpg_file_path_OCR_helper, nt_in, nt_out)
                if response_candidate is not None:
                    final_JSON_response = final_JSON_response0
                self.logger.info(f'Formatted JSON\n{final_JSON_response}')
                self.logger.info(f'Finished PaLM 2 API calls\n')

        if progress_report is not None:
            progress_report.reset_batch(f"Batch Complete")
        return final_JSON_response, total_tokens_in, total_tokens_out


    '''
    def use_falcon(self, progress_report):
        for i, path_to_crop in enumerate(self.img_paths):
            progress_report.update_batch(f"Working on image {i+1} of {len(self.img_paths)}")
            if os.path.basename(path_to_crop) in self.completed_specimens:
                self.logger.info(f'[Skipping] specimen {os.path.basename(path_to_crop)} already processed')
            else:
                filename_without_extension = os.path.splitext(os.path.basename(path_to_crop))[0]
                txt_file_path = os.path.join(self.Dirs.transcription_ind, filename_without_extension + '.json')
                txt_file_path_helper = os.path.join(self.Dirs.transcription_ind_helper, filename_without_extension + '.json')
                self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- {filename_without_extension}')

                # Use Google Vision API to get OCR
                self.OCR, self.bounds, self.text_to_box_mapping = detect_text(path_to_crop)
                if len(self.OCR) > 0:
                    self.OCR = self.OCR.replace("\'", "Minutes").replace('\"', "Seconds")

                    # Send OCR to Falcon and return formatted dictionary
                    response = OCR_to_dict_Falcon(self.logger, self.OCR, self.Voucher_Vision_Embedding)
                    # response_helper = OCR_to_helper_Falcon(self.logger, OCR) # Assuming you have a similar helper function for Falcon
                    response_helper = None
                    
                    self.logger.info(f'Finished Falcon API calls\n')
                else:
                    response = None

                if (response is not None) and (response_helper is not None):
                    # Save transcriptions to json files
                    self.write_json_to_file(txt_file_path, response)
                    # self.write_json_to_file(txt_file_path_helper, response_helper)

                    # add to the xlsx file
                    self.add_data_to_excel_from_response(self.path_transcription, response, filename_without_extension, path_to_crop, txt_file_path, txt_file_path_helper)
        progress_report.reset_batch()
    '''

    def generate_paths(self, path_to_crop, i):
        filename_without_extension = os.path.splitext(os.path.basename(path_to_crop))[0]
        txt_file_path = os.path.join(self.Dirs.transcription_ind, filename_without_extension + '.json')
        txt_file_path_OCR = os.path.join(self.Dirs.transcription_ind_OCR, filename_without_extension + '.json')
        txt_file_path_OCR_bounds = os.path.join(self.Dirs.transcription_ind_OCR_bounds, filename_without_extension + '.json')
        jpg_file_path_OCR_helper = os.path.join(self.Dirs.transcription_ind_OCR_helper, filename_without_extension + '.jpg')

        self.logger.info(f'Working on {i+1}/{len(self.img_paths)} --- {filename_without_extension}')

        return filename_without_extension, txt_file_path, txt_file_path_OCR, txt_file_path_OCR_bounds, jpg_file_path_OCR_helper

    def save_json_and_xlsx(self, response, filename_without_extension, path_to_crop, txt_file_path, jpg_file_path_OCR_helper, nt_in, nt_out):
        if response is None:
            response = self.create_null_json()
            self.write_json_to_file(txt_file_path, response)

            # Then add the null info to the spreadsheet
            response_null = self.create_null_row(filename_without_extension, path_to_crop, txt_file_path, jpg_file_path_OCR_helper)
            self.add_data_to_excel_from_response(self.path_transcription, response_null, filename_without_extension, path_to_crop, txt_file_path, jpg_file_path_OCR_helper, nt_in=0, nt_out=0)
        
        ### Set completed JSON
        else:
            response = self.clean_catalog_number(response, filename_without_extension)
            self.write_json_to_file(txt_file_path, response)
            # add to the xlsx file
            self.add_data_to_excel_from_response(self.path_transcription, response, filename_without_extension, path_to_crop, txt_file_path, jpg_file_path_OCR_helper, nt_in, nt_out)
        return response
    
    def process_specimen_batch(self, progress_report):
        try:
            if self.has_key:
                if self.model_name:
                    final_json_response, total_tokens_in, total_tokens_out = self.use_chatGPT(self.is_azure, progress_report, self.model_name)
                else:
                    final_json_response, total_tokens_in, total_tokens_out = self.use_PaLM(progress_report)
                return final_json_response, total_tokens_in, total_tokens_out
            else:
                self.logger.info(f'No API key found for {self.version_name}')
                raise Exception(f"No API key found for {self.version_name}")
        except:
            if progress_report is not None:
                progress_report.reset_batch(f"Batch Failed")
            self.logger.error("LLM call failed. Ending batch. process_specimen_batch()")
            for handler in self.logger.handlers[:]:
                handler.close()
                self.logger.removeHandler(handler)
            raise

    def process_specimen_batch_OCR_test(self, path_to_crop):
        for img_filename in os.listdir(path_to_crop):
            img_path = os.path.join(path_to_crop, img_filename)
        self.OCR, self.bounds, self.text_to_box_mapping = detect_text(img_path, self.client)



def space_saver(cfg, Dirs, logger):
    dir_out = cfg['leafmachine']['project']['dir_output']
    run_name = Dirs.run_name

    path_project = os.path.join(dir_out, run_name)

    if cfg['leafmachine']['project']['delete_temps_keep_VVE']:
        logger.name = '[DELETE TEMP FILES]'
        logger.info("Deleting temporary files. Keeping files required for VoucherVisionEditor.")
        delete_dirs = ['Archival_Components', 'Config_File']
        for d in delete_dirs:
            path_delete = os.path.join(path_project, d)
            if os.path.exists(path_delete):
                shutil.rmtree(path_delete)

    elif cfg['leafmachine']['project']['delete_all_temps']:
        logger.name = '[DELETE TEMP FILES]'
        logger.info("Deleting ALL temporary files!")
        delete_dirs = ['Archival_Components', 'Config_File', 'Original_Images', 'Cropped_Images']
        for d in delete_dirs:
            path_delete = os.path.join(path_project, d)
            if os.path.exists(path_delete):
                shutil.rmtree(path_delete)

        # Delete the transctiption folder, but keep the xlsx
        transcription_path = os.path.join(path_project, 'Transcription')
        if os.path.exists(transcription_path):
            for item in os.listdir(transcription_path):
                item_path = os.path.join(transcription_path, item)
                if os.path.isdir(item_path):  # if the item is a directory
                    if os.path.exists(item_path):
                        shutil.rmtree(item_path)  # delete the directory