Updated readme, added some further privacy things for hugging face

README.md

@@ -101,8 +101,11 @@ For Gemini, you'll need an API key, you can get one [here](https://ai.google.dev
 
 I'd recommend using GPT for most things, as it's generally better at translation.
 
-Once again, mostly straightforward, fill in your API key, Kudasai can store both
+Once again, mostly straightforward, fill in your API key, select your LLM, and select your text. You'll also need to add your settings file if on HuggingFace.
 
+You can calculate costs here or just translate. Output will show in the appropriate fields.
+
+For further details on the settings file, see [here](#translation-with-llms-settings).
 
 ---------------------------------------------------------------------------------------------------------------------------------------------------
 

modules/common/file_ensurer.py

@@ -24,6 +24,8 @@ class FileEnsurer():
     output_dir = os.path.join(script_dir, "output")
     archive_dir = os.path.join(output_dir, "archive")
 
+    hugging_face_flag = os.path.join(script_dir, "util", "hugging_face_flag.py")
+
     ## main dirs (config is just under userprofile on windows, and under home on linux); secrets are under appdata on windows, and under .config on linux
     if(os.name == 'nt'):  ## Windows
         config_dir = os.path.join(os.environ['USERPROFILE'],"KudasaiConfig")
@@ -143,6 +145,19 @@ class FileEnsurer():
     do_interrupt = False
     need_to_run_kairyou = True
 
+##-------------------start-of-check_if_hugging_space()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+    
+    @staticmethod
+    def check_if_hugging_space() -> bool:
+    
+        """
+        
+        Determines if Kudasai is running on a Hugging Face server.
+
+        """
+
+        return os.path.exists(FileEnsurer.hugging_face_flag)
+
 ##--------------------start-of-exit_kudasai()------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     @staticmethod

webgui.py

@@ -1,6 +1,7 @@
 ## built-in libraries
 import typing
 import base64
+import os
 
 ## third-party libraries
 import gradio as gr
@@ -89,6 +90,75 @@ class KudasaiGUI:
                 
                 return Logger.current_batch
             
+##-------------------start-of-get_saved_kaiseki_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            def get_saved_kaiseki_api_key() -> str:
+
+                """
+                
+                Gets the saved kaiseki api key from the config folder, if it exists.
+
+                Returns:
+                api_key (str) : The api key.
+
+                """
+
+                try:
+
+                    assert FileEnsurer.check_if_hugging_space() == False
+
+                    ## Api key is encoded in base 64 so we need to decode it before returning
+                    return base64.b64decode(FileEnsurer.standard_read_file(FileEnsurer.deepl_api_key_path).encode('utf-8')).decode('utf-8')
+                
+                except:
+                    return ""
+                
+##-------------------start-of-get_saved_openai_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                
+            def get_saved_openai_api_key() -> str:
+
+                """
+                
+                Gets the saved openai api key from the config folder, if it exists.
+
+                Returns:
+                api_key (str) : The api key.
+
+                """
+
+                try:
+
+                    assert FileEnsurer.check_if_hugging_space() == False
+
+                    ## Api key is encoded in base 64 so we need to decode it before returning
+                    return base64.b64decode(FileEnsurer.standard_read_file(FileEnsurer.openai_api_key_path).encode('utf-8')).decode('utf-8')
+                
+                except:
+                    return ""
+                
+##-------------------start-of-get_saved_gemini_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                
+            def get_saved_gemini_api_key() -> str:
+
+                """
+                
+                Gets the saved gemini api key from the config folder, if it exists.
+
+                Returns:
+                api_key (str) : The api key.
+
+                """
+
+                try:
+
+                    assert FileEnsurer.check_if_hugging_space() == False
+
+                    ## Api key is encoded in base 64 so we need to decode it before returning
+                    return base64.b64decode(FileEnsurer.standard_read_file(FileEnsurer.gemini_api_key_path).encode('utf-8')).decode('utf-8')
+                
+                except:
+                    return ""
+                
 ##-------------------start-of-set_kijiku_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
                 
             async def set_kijiku_api_key(api_key) -> None:
@@ -121,6 +191,31 @@ class KudasaiGUI:
                 except:
                     raise gr.Error("Invalid API key")
                 
+##-------------------start-of-update_kijiku_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                
+            def update_kijiku_api_key(api_key) -> None:
+
+                """
+
+                Updates the kijiku api key.
+
+                Parameters:
+                api_key (str) : The api key.
+
+                """
+
+                if(FileEnsurer.check_if_hugging_space() == True):
+                    return
+
+                ## also gonna want to update the api key file with the new api key
+                if(Kijiku.LLM_TYPE == "openai"):
+                    path_to_api_key = FileEnsurer.openai_api_key_path
+
+                else:
+                    path_to_api_key = FileEnsurer.gemini_api_key_path
+
+                FileEnsurer.standard_overwrite_file(path_to_api_key, base64.b64encode(str(api_key).encode('utf-8')).decode('utf-8'), omit=True)
+
 ##-------------------start-of-create_new_key_value_tuple_pairs()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------    
 
             def create_new_key_value_tuple_pairs(kijiku_settings:typing.List[str]) -> typing.List[typing.Tuple[str, str]]:
@@ -268,7 +363,7 @@ class KudasaiGUI:
                             self.input_text_kaiseki = gr.Textbox(label='Japanese Text', placeholder='Use this or the text file input, if you provide both, Kudasai will use the file input.', lines=10, show_label=True, interactive=True)
 
                             with gr.Row():
-                                self.kaiseki_api_key_input_field = gr.Textbox(label='API Key', lines=1, show_label=True, interactive=True, type='password')
+                                self.kaiseki_api_key_input_field = gr.Textbox(label='API Key', value=get_saved_kaiseki_api_key, lines=1, show_label=True, interactive=True, type='password')
 
                             with gr.Row():
                                 self.kaiseki_translate_button = gr.Button('Translate', variant="primary")
@@ -301,13 +396,13 @@ class KudasaiGUI:
                         with gr.Column():
                             self.input_txt_file_kijiku = gr.File(label='TXT file with Japanese Text', file_count='single', file_types=['.txt'], type='filepath', interactive=True)
                             self.input_text_kijiku = gr.Textbox(label='Japanese Text', placeholder='Use this or the text file input, if you provide both, Kudasai will use the file input.', lines=10, show_label=True, interactive=True, type='text')
-                            self.input_kijiku_rules_file = gr.File(value = FileEnsurer.config_kijiku_rules_path, label='Kijiku Rules File', file_count='single', file_types=['.json'], type='filepath')
+                            self.input_kijiku_rules_file = gr.File(value = FileEnsurer.config_kijiku_rules_path if not FileEnsurer.check_if_hugging_space() else FileEnsurer.blank_rules_path, label='Kijiku Rules File', file_count='single', file_types=['.json'], type='filepath')
 
                             with gr.Row():
                                 self.llm_option_dropdown = gr.Dropdown(label='LLM Option', choices=["OpenAI", "Gemini"], value="OpenAI", show_label=True, interactive=True)
                             
                             with gr.Row():
-                                self.kijiku_api_key_input = gr.Textbox(label='API Key', lines=1, max_lines=2, show_label=True, interactive=True, type='password')
+                                self.kijiku_api_key_input = gr.Textbox(label='API Key', value=get_saved_openai_api_key, lines=1, max_lines=2, show_label=True, interactive=True, type='password')
 
                             with gr.Row():
                                 self.kijiku_translate_button = gr.Button('Translate', variant="primary")
@@ -711,6 +806,9 @@ class KudasaiGUI:
 
                             indexed_text = Kudasai.mark_indexed_names(text_to_index, unique_names)
 
+                            if(FileEnsurer.check_if_hugging_space == True):
+                                os.remove(FileEnsurer.output_dir)
+
                             return indexed_text, indexing_log, log_text, log_text, error_log
 
                         else:
@@ -772,6 +870,9 @@ class KudasaiGUI:
 
                     log_text = FileEnsurer.standard_read_file(Logger.log_file_path)
 
+                    if(FileEnsurer.check_if_hugging_space == True):
+                        os.remove(FileEnsurer.output_dir)
+
                     return preprocessed_text, preprocessing_log, log_text, log_text, error_log
             
                 else:
@@ -848,6 +949,13 @@ class KudasaiGUI:
 
                 error_text = FileEnsurer.standard_read_file(FileEnsurer.error_log_path)
 
+                if(FileEnsurer.check_if_hugging_space == True):
+                    os.remove(FileEnsurer.output_dir)
+
+                else:
+                    ## also gonna want to update the api key file with the new api key
+                    FileEnsurer.standard_overwrite_file(FileEnsurer.deepl_api_key_path, base64.b64encode(str(api_key_input).encode('utf-8')).decode('utf-8'), omit=True)
+
                 return translated_text, je_check_text, log_text, error_text
             
 ##-------------------start-of-translate_with_kijiku()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -928,7 +1036,13 @@ class KudasaiGUI:
                 log_text = FileEnsurer.standard_read_file(Logger.log_file_path)
 
                 error_text = FileEnsurer.standard_read_file(FileEnsurer.error_log_path)
+
+                if(FileEnsurer.check_if_hugging_space == True):
+                    os.remove(FileEnsurer.output_dir)
                 
+                ## then overwrite the api key file with the new api key
+                update_kijiku_api_key(api_key)
+
                 return translated_text, je_check_text, log_text, error_text
             
 ##-------------------start-of-kijiku_calculate_costs_button_click()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -1001,6 +1115,11 @@ class KudasaiGUI:
                 
                 gr.Info(cost_estimation)
 
+                if(FileEnsurer.check_if_hugging_space == True):
+                    os.remove(FileEnsurer.output_dir)
+
+                update_kijiku_api_key(api_key)
+
                 return cost_estimation
             
 ##-------------------start-of-clear_index_tab()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -1532,6 +1651,28 @@ class KudasaiGUI:
                     gr.Info("Preprocessed text copied to Kijiku")
                     return input_text
                 
+##-------------------start-of-switch_kijiku_api_key_value()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+                
+            def switch_kijiku_api_key_value(llm_type) -> str:
+
+                """
+                
+                Switches the LLM type value.
+
+                Parameters:
+                llm_type (str) : The LLM type.
+
+                Returns:
+                llm_type (str) : The LLM type.
+
+                """
+
+                if(llm_type == "OpenAI"):
+                    return get_saved_openai_api_key()
+                
+                else:
+                    return get_saved_gemini_api_key()
+                
 ##-------------------start-of-Listener-Declaration---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 ##-------------------start-of-load()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -1872,6 +2013,13 @@ class KudasaiGUI:
                                     
                                     outputs=[self.logging_tab_debug_log_output_field, self.logging_tab_error_log_output_field])
             
+##-------------------start-of-kijiku_api_key_input.change()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            self.llm_option_dropdown.change(switch_kijiku_api_key_value,
+                                             inputs=[self.llm_option_dropdown],
+                                            
+                                            outputs=[self.kijiku_api_key_input])
+            
 ##-------------------start-of-save_to_file_indexed_text_click()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
             
             self.save_to_file_indexed_text.click(lambda text: text, ## save text as is