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

vouchervision/API_validation.py

@@ -6,6 +6,8 @@ from langchain_openai import AzureChatOpenAI
 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 datetime import datetime
 import google.generativeai as genai
 from google.oauth2 import service_account
@@ -37,10 +39,10 @@ class APIvalidation:
             return False
             
     def check_openai_api_key(self):
-        if self.cfg_private:
-            openai.api_key = self.cfg_private['openai']['OPENAI_API_KEY']
-        else:
+        if self.is_hf:
             openai.api_key = os.getenv('OPENAI_API_KEY')
+        else:
+            openai.api_key = self.cfg_private['openai']['OPENAI_API_KEY']
 
         try:
             openai.models.list()
@@ -48,52 +50,6 @@ class APIvalidation:
         except:
             return False
         
-    # def check_google_ocr_api_key(self): ##################################################################################### maybe check without initi, post the vertexai
-    #     # if os.path.exists(self.cfg_private['google_cloud']['path_json_file']):
-    #     #     os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.cfg_private['google_cloud']['path_json_file']
-    #     # elif os.path.exists(self.cfg_private['google_cloud']['path_json_file_service_account2']):
-    #     #     os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.cfg_private['google_cloud']['path_json_file_service_account2']
-    #     # else:
-    #     #     return False
-        
-    #     try:
-    #         if not self.cfg_private:
-    #             # Convert JSON key from string to a dictionary
-    #             service_account_json_str = os.getenv('google_service_account_json')
-    #             if not service_account_json_str:
-    #                 print("Service account JSON not found in environment variables.")
-    #                 return False
-
-    #             # Convert JSON string to a dictionary
-    #             service_account_info = json.loads(service_account_json_str)
-    #             # Create credentials from the service account info
-    #             credentials = service_account.Credentials.from_service_account_info(service_account_info)
-    #             # Initialize the client with the credentials
-    #             client = vision.ImageAnnotatorClient(credentials=credentials)
-    #             logo_path = os.path.join(self.dir_home, 'img','logo.png')
-    #             with io.open(logo_path, 'rb') as image_file:
-    #                 content = image_file.read()
-    #             image = vision.Image(content=content)
-    #             response = client.document_text_detection(image=image)
-    #             texts = response.text_annotations       
-    #             normal_cleaned_text = texts[0].description if texts else None
-    #             print(f"OCR TEST: {normal_cleaned_text}")
-    #         else:
-    #             logo_path = os.path.join(self.dir_home, 'img','logo.png')
-    #             client = vision.ImageAnnotatorClient()
-    #             with io.open(logo_path, 'rb') as image_file:
-    #                 content = image_file.read()
-    #             image = vision.Image(content=content)
-    #             response = client.document_text_detection(image=image)
-    #             texts = response.text_annotations       
-    #             normal_cleaned_text = texts[0].description if texts else None
-    #         if normal_cleaned_text:
-    #             return True
-    #         else:
-    #             return False
-    #     except:
-    #         return False
-        
     def check_azure_openai_api_key(self):
         if not self.is_hf:
             try:
@@ -171,126 +127,97 @@ class APIvalidation:
         except Exception as e:  # Replace with a more specific exception if possible
             return False
         
-    # def get_google_credentials(self):
-    #     # Convert JSON key from string to a dictionary
-    #     service_account_json_str = os.getenv('google_service_account_json')
+    def check_google_vision_client(self):
+        results = {"ocr_print": False, "ocr_hand": False}
 
-    #     with tempfile.NamedTemporaryFile(mode="w+", delete=False,suffix=".json") as temp:
-    #         temp.write(service_account_json_str)
-    #         temp_filename = temp.name
-        
-    #     return temp_filename
+        if self.is_hf:
+            client_beta = vision_beta.ImageAnnotatorClient(credentials=self.get_google_credentials())
+            client = vision.ImageAnnotatorClient(credentials=self.get_google_credentials())
+        else:
+            client_beta = vision_beta.ImageAnnotatorClient(credentials=self.get_google_credentials()) 
+            client = vision.ImageAnnotatorClient(credentials=self.get_google_credentials())
         
-    # https://cloud.google.com/docs/authentication/provide-credentials-adc
-    def get_google_credentials(self):
-            creds_json_str = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
-            credentials = service_account.Credentials.from_service_account_info(json.loads(creds_json_str))
-            return credentials
+        try:
+            with open(os.path.join(self.dir_home,'demo', 'ocr_test', 'ocr_test.jpg'), "rb") as image_file:
+                content = image_file.read()
+        except:
+            with open("./demo/ocr_test/ocr_test.jpg", "rb") as image_file:
+                content = image_file.read()
 
-    # def init_google_client(opt, opt2):
-    #     # Fetch the credentials JSON string from Hugging Face Secrets
-    #     creds_json_str = os.getenv('google_service_account_json')
+        try:
+            image = vision_beta.Image(content=content)
+            image_context = vision_beta.ImageContext(language_hints=["en-t-i0-handwrit"])
+            response = client_beta.document_text_detection(image=image, image_context=image_context)
+            texts = response.text_annotations
+            
+            print(f"OCR Hand:\n{texts[0].description}")
+            if len(texts[0].description) > 0:
+                results['ocr_hand'] = True
+        except:
+            pass
 
-    #     if creds_json_str:
-    #         creds_dict = json.loads(creds_json_str)
-    #         credentials = service_account.Credentials.from_service_account_info(creds_dict)
+        try:
+            image = vision.Image(content=content)
+            response = client.document_text_detection(image=image)
+            texts = response.text_annotations
+        
+            print(f"OCR Print:\n{texts[0].description}")
+            if len(texts[0].description) > 0:
+                results['ocr_print'] = True
+        except:
+            pass
 
-    #         # Initialize Google API client (if needed for your use case)
-    #         client = build(opt, opt2, credentials=credentials)  # Adjust with actual service details
+        return results
 
-    #         return client, credentials
-    #     else:
-    #         print("Google API credentials not found.")
 
     def check_google_vertex_genai_api_key(self):
         results = {"palm2": False, "gemini": False}
-        if not self.is_hf:
-            try: # Local
-                # Assuming genai and vertexai are clients for Google services
-                # os.environ["GOOGLE_API_KEY"] = self.cfg_private['google_palm']['google_palm_api']
-                # genai.configure(api_key=self.cfg_private['google_palm']['google_palm_api'])
-                vertexai.init(project= self.cfg_private['google_palm']['project_id'], location=self.cfg_private['google_palm']['location'])
-
-                try:
-                    model = TextGenerationModel.from_pretrained("text-bison@001")
-                    response = model.predict("Hello")
-                    test_response_palm = response.text
-                    # llm_palm = ChatGoogleGenerativeAI(model="text-bison@001")
-                    # test_response_palm = llm_palm.invoke("Hello")
-                    if test_response_palm:
-                        results["palm2"] = True
-                except Exception as e:  
-                    pass
-
-                try:
-                    model = GenerativeModel("gemini-pro")
-                    response = model.generate_content("Hello")
-                    test_response_gemini = response.text
-                    # llm_gemini = ChatGoogleGenerativeAI(model="gemini-pro")
-                    # test_response_gemini = llm_gemini.invoke("Hello")
-                    if test_response_gemini:
-                        results["gemini"] = True
-                except Exception as e:  
-                    pass
-
-
-                return results
-            except Exception as e:  # Replace with a more specific exception if possible
-                return results
+
+        try:
+            model = TextGenerationModel.from_pretrained("text-bison@001")
+            response = model.predict("Hello")
+            test_response_palm = response.text
+            if test_response_palm:
+                results["palm2"] = True
+                print(f"palm2 pass [{test_response_palm}]")
+            else:
+                print(f"palm2 fail [{test_response_palm}]")
+
+        except Exception as e:
+            print(f"palm2 fail2 [{test_response_palm}]")
+            
+
+        try:
+            model = GenerativeModel("gemini-pro")
+            response = model.generate_content("Hello")
+            test_response_gemini = response.text
+            if test_response_gemini:
+                results["gemini"] = True
+                print(f"gemini pass [{test_response_gemini}]")
+            else:
+                print(f"gemini fail [{test_response_gemini}]")
+
+        except Exception as e:
+            print(f"palm2 fail2 [{test_response_gemini}]")
+
+        return results
+
+
+
+    def get_google_credentials(self):
+        if self.is_hf:
+            creds_json_str = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
+            credentials = service_account.Credentials.from_service_account_info(json.loads(creds_json_str))
+            return credentials
         else:
-            ### is hugging face
-            try:
-                # Assuming genai and vertexai are clients for Google services
-                # os.environ["GOOGLE_API_KEY"] = os.getenv('PALM_API_KEY')
-                # os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.get_google_credentials()
-                # client, credentials = self.init_google_client('gemini-pro', 'v1')
-                # print(credentials)
-                print("service account")
-                palm_api_key = os.getenv('PALM_API_KEY')
-                google_project_id = os.getenv('GOOGLE_PROJECT_ID')
-                google_location = os.getenv('GOOGLE_LOCATION')
-                os.environ['GOOGLE_API_KEY'] =  os.getenv('PALM_API_KEY')
-                vertexai.init(project=os.getenv('GOOGLE_PROJECT_ID'), location=os.getenv('GOOGLE_LOCATION'),credentials=self.get_google_credentials())
-                # genai.configure(api_key=palm_api_key)
-                # vertexai.init(project=google_project_id, location=google_location)#, credentials=credentials)
-                print("service account pass")
-
-                try:
-                    model = TextGenerationModel.from_pretrained("text-bison@001")
-                    response = model.predict("Hello")
-                    test_response_palm = response.text
-                    # llm_palm = ChatGoogleGenerativeAI(model="text-bison@001")
-                    # test_response_palm = llm_palm.invoke("Hello")
-                    if test_response_palm:
-                        results["palm2"] = True
-                        print(f"palm2 pass [{test_response_palm}]")
-                    else:
-                        print(f"palm2 yes [{test_response_palm}]")
-
-                except Exception as e:  
-                    print(f"palm2 [{e}]")
-                    pass
-
-                try:
-                    model = GenerativeModel("gemini-pro")
-                    response = model.generate_content("Hello")
-                    test_response_gemini = response.text
-                    # llm_gemini = ChatGoogleGenerativeAI(model="gemini-pro")
-                    # test_response_gemini = llm_gemini.invoke("Hello")
-                    if test_response_gemini:
-                        results["gemini"] = True
-                        print(f"gemini pass [{test_response_palm}]")
-                    else:
-                        print(f"gemini yes [{test_response_palm}]")
-
-                except Exception as e:  
-                    print(f"gemini [{e}]")
-                    pass
-
-                return results
-            except Exception as e:  # Replace with a more specific exception if possible
-                print(f"Immediate [{e}]")
-                return results
+            with open(self.cfg_private['google_cloud']['GOOGLE_APPLICATION_CREDENTIALS'], 'r') as file:
+                data = json.load(file)
+                creds_json_str = json.dumps(data)
+                credentials = service_account.Credentials.from_service_account_info(json.loads(creds_json_str))
+                os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = creds_json_str
+                return credentials
+
+
 
     def report_api_key_status(self):
         missing_keys = []
@@ -299,31 +226,39 @@ class APIvalidation:
         if not self.is_hf:
             k_OPENAI_API_KEY = self.cfg_private['openai']['OPENAI_API_KEY']
             k_openai_azure = self.cfg_private['openai_azure']['api_version']
-            k_google_palm_api = self.cfg_private['google_palm']['google_palm_api']
+            # k_google_palm_api = self.cfg_private['google_palm']['google_palm_api']
+
             k_project_id = self.cfg_private['google_palm']['project_id']
             k_location = self.cfg_private['google_palm']['location']
+            k_google_application_credentials = self.cfg_private['google_cloud']['GOOGLE_APPLICATION_CREDENTIALS']
+            
             k_mistral = self.cfg_private['mistral']['mistral_key']
             k_here = self.cfg_private['here']['api_key']
             k_opencage = self.cfg_private['open_cage_geocode']['api_key']
         else:
             k_OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
             k_openai_azure = os.getenv('AZURE_API_VERSION')
-            k_google_palm_api = os.getenv('PALM_API_KEY')
+            # k_google_palm_api = os.getenv('PALM_API_KEY')
+
             k_project_id = os.getenv('GOOGLE_PROJECT_ID')
             k_location = os.getenv('GOOGLE_LOCATION')
             k_mistral = os.getenv('MISTRAL_API_KEY')
-            k_here = os.getenv('here_api_key')
+            k_here = os.getenv('HERE_API_KEY')
             k_opencage = os.getenv('open_cage_geocode')
 
 
         # Check each key and add to the respective list
         # Google OCR key check
-        if self.has_API_key(k_google_palm_api) and self.has_API_key(k_project_id) and self.has_API_key(k_location):
-            is_valid = True #self.check_google_ocr_api_key() ###############################################################################################################################
-            if is_valid:
-                present_keys.append('Google OCR (Valid)')
+        if self.has_API_key(k_google_application_credentials) and self.has_API_key(k_project_id) and self.has_API_key(k_location):
+            google_ocr_results = self.check_google_vision_client() 
+            if google_ocr_results['ocr_print']:
+                present_keys.append('Google OCR Print (Valid)')
+            else:
+                present_keys.append('Google OCR Print (Invalid)')
+            if google_ocr_results['ocr_hand']:
+                present_keys.append('Google OCR Handwriting (Valid)')
             else:
-                present_keys.append('Google OCR (Invalid)')
+                present_keys.append('Google OCR Handwriting (Invalid)')
         else:
             missing_keys.append('Google OCR')
         
@@ -349,7 +284,8 @@ class APIvalidation:
             missing_keys.append('Azure OpenAI')
 
         # Google PALM2/Gemini key check
-        if self.has_API_key(k_google_palm_api) and self.has_API_key(k_project_id) and self.has_API_key(k_location):
+        if self.has_API_key(k_google_application_credentials) and self.has_API_key(k_project_id) and self.has_API_key(k_location): ##################
+            vertexai.init(project=os.getenv('GOOGLE_PROJECT_ID'), location=os.getenv('GOOGLE_LOCATION'), credentials=self.get_google_credentials())
             google_results = self.check_google_vertex_genai_api_key()
             if google_results['palm2']:
                 present_keys.append('Palm2 (Valid)')

vouchervision/OCR_google_cloud_vision.py

@@ -71,28 +71,22 @@ class OCRGoogle:
         self.trOCR_characters = None
         self.set_client()
 
-
         
     def set_client(self):
         if self.is_hf:
-            service_account_json_str = os.getenv('google_service_account_json')
-            if not service_account_json_str:
-                print("Service account JSON not found in environment variables.")
-                return False
-
-            # Convert JSON string to a dictionary
-            service_account_info = json.loads(service_account_json_str)
-            # Create credentials from the service account info
-            credentials = service_account.Credentials.from_service_account_info(service_account_info)
-            # Initialize the client with the credentials
-            self.client_beta = vision_beta.ImageAnnotatorClient(credentials=credentials)
-            self.client = vision.ImageAnnotatorClient(credentials=credentials)
+            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()
 
 
-
+    def get_google_credentials(self):
+        creds_json_str = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
+        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

vouchervision/utils_VoucherVision.py

@@ -410,194 +410,132 @@ class VoucherVision():
         else:
             return False
         
-    # def get_google_credentials(self):
-    #     # Convert JSON key from string to a dictionary
-    #     service_account_json_str = os.getenv('google_service_account_json')
 
-    #     with tempfile.NamedTemporaryFile(mode="w+", delete=False,suffix=".json") as temp:
-    #         temp.write(service_account_json_str)
-    #         temp_filename = temp.name
-        
-    #     return temp_filename   
-    
-    # def init_google_client(opt, opt2):
-    #     # Fetch the credentials JSON string from Hugging Face Secrets
-    #     creds_json_str = os.getenv('google_service_account_json')
-
-    #     if creds_json_str:
-    #         creds_dict = json.loads(creds_json_str)
-    #         credentials = service_account.Credentials.from_service_account_info(creds_dict)
-
-    #         # Initialize Google API client (if needed for your use case)
-    #         client = build(opt, opt2, credentials=credentials)  # Adjust with actual service details
-
-    #         return client, credentials
-    #     else:
-    #         print("Google API credentials not found.")
     def get_google_credentials(self):
+        if self.is_hf:
             creds_json_str = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
             credentials = service_account.Credentials.from_service_account_info(json.loads(creds_json_str))
             return credentials
+        else:
+            with open(self.cfg_private['google_cloud']['GOOGLE_APPLICATION_CREDENTIALS'], 'r') as file:
+                data = json.load(file)
+                creds_json_str = json.dumps(data)
+                credentials = service_account.Credentials.from_service_account_info(json.loads(creds_json_str))
+                os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = creds_json_str
+                return credentials
         
+
     def set_API_keys(self):
         if self.is_hf:
-            openai_api_key = os.getenv('OPENAI_API_KEY')
-            # google_application_credentials = os.getenv('google_service_account_json')
-            palm_api_key = os.getenv('PALM_API_KEY')
-            mistral_api_key = os.getenv('MISTRAL_API_KEY')
-            here_api_key = os.getenv('here_api_key')
-            here_app_id = os.getenv('here_app_id')
-            open_cage_api_key = os.getenv('open_cage_geocode')
-            google_project_id = os.getenv('GOOGLE_PROJECT_ID')
-            google_project_location = os.getenv('GOOGLE_LOCATION')
-            # os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.get_google_credentials()
-
-
-
-            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
-            self.has_key_mistral = mistral_api_key is not None
-            self.has_key_here = here_api_key is not None
-            self.has_hey_here = here_app_id is not None
-            self.has_open_cage_geocode = open_cage_api_key is not None
-            self.has_key_google_project_id = google_project_id is not None
-            self.has_key_google_project_location = google_project_location is not None
-
-            # genai_api_key = os.getenv('PALM_API_KEY')
-            os.environ['GOOGLE_API_KEY'] =  os.getenv('PALM_API_KEY')
-            vertexai.init(project=os.getenv('GOOGLE_PROJECT_ID'), location=os.getenv('GOOGLE_LOCATION'))
-
-
-            os.environ['GOOGLE_API_KEY'] =  os.getenv('PALM_API_KEY')
-            vertexai.init(project=os.getenv('GOOGLE_PROJECT_ID'), location=os.getenv('GOOGLE_LOCATION'),credentials=self.get_google_credentials())
-            # try:
-                # if genai_api_key:
-                    # genai.configure(api_key=genai_api_key)
-            # except:
-                # print(f"failed genai.configure")
-
-            # try:
-            #     if google_project_id and google_location:
-            #         # clien, credentials = self.init_google_client('gemini-pro', 'v1')
-            #         # print(credentials)
-            #         vertexai.init(project=google_project_id, location=google_location)#, credentials=credentials)
-            # except:
-            #     print(f"failed vertexai.init")
-            # if self.has_key_openai:
-            #     openai.api_key = openai_api_key
-
-            # if self.has_key_google_project_id and self.has_key_google_project_location:
-            #     genai.configure(api_key=os.getenv('PALM_API_KEY'))
-            #     vertexai.init(project=os.getenv('GOOGLE_PROJECT_ID'), location=os.getenv('GOOGLE_LOCATION'))
-
-            if os.getenv('AZURE_API_KEY') is not None:
-                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')
-
-                if azure_api_version and azure_api_key and azure_api_base and azure_organization:# and azure_api_type and azure_deployment_name:
-
-                    self.has_key_azure_openai = True
-                    self.llm = AzureChatOpenAI(
-                        deployment_name = 'gpt-35-turbo',#'gpt-35-turbo',
-                        openai_api_version = azure_api_version,
-                        openai_api_key = azure_api_key,
-                        azure_endpoint = azure_api_base,
-                        openai_organization = azure_organization,
-                    )
-
-
-        else:
             self.dir_home = os.path.dirname(os.path.dirname(__file__))
             self.path_cfg_private = os.path.join(self.dir_home, 'PRIVATE_DATA.yaml')
             self.cfg_private = get_cfg_from_full_path(self.path_cfg_private)
 
-            self.has_key_openai = self.has_API_key(self.cfg_private['openai']['OPENAI_API_KEY'])
+            k_openai = self.cfg_private['openai']['OPENAI_API_KEY']
+            k_openai_azure = self.cfg_private['openai_azure']['api_version']
 
-            self.has_key_azure_openai = self.has_API_key(self.cfg_private['openai_azure']['api_version'])
+            k_google_project_id = self.cfg_private['google_palm']['project_id']
+            k_google_location = self.cfg_private['google_palm']['location']
+            k_google_application_credentials = self.cfg_private['google_cloud']['GOOGLE_APPLICATION_CREDENTIALS']
             
-            self.has_key_google_OCR = self.has_API_key(self.cfg_private['google_cloud']['path_json_file'])
+            k_mistral = self.cfg_private['mistral']['mistral_key']
+            k_here = self.cfg_private['here']['api_key']
+            k_opencage = self.cfg_private['open_cage_geocode']['api_key']
+        else:
+            self.dir_home = os.path.dirname(os.path.dirname(__file__))
+            self.path_cfg_private = None
+            self.cfg_private = None
+
+            k_openai = os.getenv('OPENAI_API_KEY')
+            k_openai_azure = os.getenv('AZURE_API_VERSION')
 
-            self.has_key_palm2 = self.has_API_key(self.cfg_private['google_palm']['google_palm_api'])
-            self.has_key_google_project_id = self.has_API_key(self.cfg_private['google_palm']['project_id'])
-            self.has_key_google_project_location = self.has_API_key(self.cfg_private['google_palm']['location'])
+            k_google_project_id = os.getenv('GOOGLE_PROJECT_ID')
+            k_google_location = os.getenv('GOOGLE_LOCATION')
+            k_google_application_credentials = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
 
-            self.has_key_mistral = self.has_API_key(self.cfg_private['mistral']['mistral_key'])
+            k_mistral = os.getenv('MISTRAL_API_KEY')
+            k_here = os.getenv('HERE_API_KEY')
+            k_opencage = os.getenv('open_cage_geocode')
 
-            self.has_key_here = self.has_API_key(self.cfg_private['here']['api_key'])
 
-            self.has_open_cage_geocode = self.has_API_key(self.cfg_private['open_cage_geocode']['api_key'])
+        self.has_key_openai = self.has_API_key(k_openai)
+        self.has_key_azure_openai = self.has_API_key(k_openai_azure)
+        
+        self.has_key_google_project_id = self.has_API_key(k_google_project_id)
+        self.has_key_google_location = self.has_API_key(k_google_location)
+        self.has_key_google_application_credentials = self.has_API_key(k_google_application_credentials)
+
+        self.has_key_mistral = self.has_API_key(k_mistral)
+        self.has_key_here = self.has_API_key(k_here)
+        self.has_key_open_cage_geocode = self.has_API_key(k_opencage)
+
+        
+        ### Google - OCR, Palm2, Gemini
+        if self.is_hf:
+            if self.has_key_google_application_credentials and self.has_key_google_project_id and self.has_key_google_location:
+                vertexai.init(project=os.getenv('GOOGLE_PROJECT_ID'), location=os.getenv('GOOGLE_LOCATION'), credentials=self.get_google_credentials())
+        
 
-            if self.has_key_openai:
+        ### OpenAI
+        if self.has_key_openai:
+            if self.is_hf:
+                openai.api_key = os.getenv('OPENAI_API_KEY')
+            else:
                 openai.api_key = self.cfg_private['openai']['OPENAI_API_KEY']
                 os.environ["OPENAI_API_KEY"] = self.cfg_private['openai']['OPENAI_API_KEY']
+
+
+        ### OpenAI - Azure
+        if self.has_key_azure_openai:
+            if self.is_hf:
+                # Initialize the Azure OpenAI client
+                self.llm = AzureChatOpenAI(
+                    deployment_name = 'gpt-35-turbo',#'gpt-35-turbo',
+                    openai_api_version = os.getenv('AZURE_API_VERSION'),
+                    openai_api_key = os.getenv('AZURE_API_KEY'),
+                    azure_endpoint = os.getenv('AZURE_API_BASE'),
+                    openai_organization = os.getenv('AZURE_ORGANIZATION'),
+                )
+                self.has_key_azure_openai = True
                 
-            if self.has_key_azure_openai:
-                # os.environ["OPENAI_API_KEY"] = self.cfg_private['openai_azure']['openai_api_key']
+            else:
+                # Initialize the Azure OpenAI client
                 self.llm = AzureChatOpenAI(
                     deployment_name = 'gpt-35-turbo',#'gpt-35-turbo',
                     openai_api_version = self.cfg_private['openai_azure']['api_version'],
                     openai_api_key = self.cfg_private['openai_azure']['openai_api_key'],
                     azure_endpoint = self.cfg_private['openai_azure']['openai_api_base'],
-                    # openai_api_base=self.cfg_private['openai_azure']['openai_api_base'],
                     openai_organization = self.cfg_private['openai_azure']['openai_organization'],
-                    # openai_api_type = self.cfg_private['openai_azure']['openai_api_type']
                 )
-            
-            # This is frustrating. a #TODO is to figure out when/why these methods conflict with the permissions set in the Palm/Gemini calls
-            name_check = self.cfg['leafmachine']['LLM_version'].lower().split(' ')
-            if ('google' in name_check) or( 'palm' in name_check) or ('gemini' in name_check):
-                os.environ['GOOGLE_PROJECT_ID'] = self.cfg_private['google_palm']['project_id'] # gemini
-                os.environ['GOOGLE_LOCATION'] = self.cfg_private['google_palm']['location'] # gemini
-                # genai.configure(api_key=self.cfg_private['google_palm']['google_palm_api'])
-                os.environ['GOOGLE_API_KEY'] = self.cfg_private['google_palm']['google_palm_api']
-                vertexai.init(project=os.environ['GOOGLE_PROJECT_ID'], location=os.environ['GOOGLE_LOCATION'])
-
-
-
-                # os.environ.pop("GOOGLE_APPLICATION_CREDENTIALS", None)
-                # os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.cfg_private['google_cloud']['path_json_file'] #### 
-                # os.environ['GOOGLE_API_KEY'] = self.cfg_private['google_palm']['google_palm_api']
-
-
-            ##### NOTE: this is how you can use ONLY OCR. If you get a vertexAI login it should work without loading all this
-            # else:
-            #     if self.has_key_google_OCR:
-            #         if os.path.exists(self.cfg_private['google_cloud']['path_json_file']):
-            #             os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.cfg_private['google_cloud']['path_json_file']
-            #         elif os.path.exists(self.cfg_private['google_cloud']['path_json_file_service_account2']):
-            #             os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.cfg_private['google_cloud']['path_json_file_service_account2']
-            #         else:
-            #             raise f"Google JSON API key file not found"
-
-            ##### NOTE: This should also be covered by vertexAI now
-            # if self.has_key_palm2:
-            #     os.environ['PALM'] = self.cfg_private['google_palm']['google_palm_api']
-            #     os.environ['GOOGLE_PROJECT_ID'] = self.cfg_private['google_palm']['project_id'] # gemini
-            #     os.environ['GOOGLE_LOCATION'] = self.cfg_private['google_palm']['location'] # gemini
-            #     os.environ['GOOGLE_API_KEY'] = self.cfg_private['google_palm']['google_palm_api']
-
-            if self.has_key_mistral:
+                self.has_key_azure_openai = True
+                
+
+        ### Mistral
+        if self.has_key_mistral:
+            if self.is_hf:
+                pass # Already set
+            else:
                 os.environ['MISTRAL_API_KEY'] = self.cfg_private['mistral']['mistral_key']
 
-            if self.has_key_here:
-                os.environ['here_app_id'] = self.cfg_private['here']['app_id']
-                os.environ['here_api_key'] = self.cfg_private['here']['api_key']
 
-            if self.has_open_cage_geocode:
-                os.environ['open_cage_geocode'] = self.cfg_private['open_cage_geocode']['api_key']
-            
+        ### HERE
+        if self.has_key_here:
+            if self.is_hf:
+                pass # Already set
+            else:
+                os.environ['HERE_APP_ID'] = self.cfg_private['here']['app_id']
+                os.environ['HERE_API_KEY'] = self.cfg_private['here']['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)
 
+        ### HERE
+        if self.has_key_open_cage_geocode:
+            if self.is_hf:
+                pass # Already set
+            else:
+                os.environ['OPENCAGE_API_KEY'] = self.cfg_private['open_cage_geocode']['api_key']
+                
 
+        
     def clean_catalog_number(self, data, filename_without_extension):
         #Cleans up the catalog number in data if it's a dict
         

vouchervision/utils_geolocate_HERE.py

@@ -150,28 +150,28 @@ def validate_coordinates_here(record, replace_if_success_geo=False):
     query_reverse = "42,-83" # cannot have any spaces
     # params = {
     #     'q': query_loc,
-    #     'apiKey': os.environ['here_api_key'],
+    #     'apiKey': os.environ['HERE_API_KEY'],
     # }'''
 
     
     params_rev = {
         'at': query_reverse,
-        'apiKey': os.environ['here_api_key'],
+        'apiKey': os.environ['HERE_API_KEY'],
         'lang': 'en',
     }
     params_reverse_verbatim = {
         'at': query_reverse_verbatim,
-        'apiKey': os.environ['here_api_key'],
+        'apiKey': os.environ['HERE_API_KEY'],
         'lang': 'en',
     }
     params_forward = {
         'q': query_forward,
-        'apiKey': os.environ['here_api_key'],
+        'apiKey': os.environ['HERE_API_KEY'],
         'lang': 'en',
     }
     params_forward_locality = {
         'q': query_forward_locality,
-        'apiKey': os.environ['here_api_key'],
+        'apiKey': os.environ['HERE_API_KEY'],
         'lang': 'en',
     }
 

vouchervision/utils_geolocate_OpenCage.py

@@ -54,7 +54,7 @@ def validate_coordinates_opencage(record, replace_if_success_geo=False):
         'GEO_continent': '',
     }
     
-    geocoder = OpenCageGeocode(os.environ['open_cage_geocode'])
+    geocoder = OpenCageGeocode(os.environ['OPENCAGE_API_KEY'])
 
     query_loc = ', '.join(filter(None, [record.get('municipality', '').strip(), 
                                         record.get('county', '').strip(),