Update app.py

app.py

@@ -14,6 +14,7 @@ import unicodedata
 import zipfile
 
 import gradio as gr
+from huggingface_hub import InferenceClient
 import torch
 import yt_dlp
 
@@ -180,6 +181,7 @@ print(r"""
 # Perform Platform Check
 userOS = ""
 
+global summary
 
 def platform_check():
     global userOS
@@ -388,16 +390,16 @@ def process_url(url, num_speakers, whisper_model, custom_prompt, offset, api_nam
 
             if summary_file_path and os.path.exists(summary_file_path):
                 return formatted_transcription, summary_text, prettified_json_file_path, summary_file_path, video_file_path, None
+            #elif api_name.lower() == 'huggingface':
+            #    return formatted_transcription, waiting_summary, prettified_json_file_path, None, video_file_path, None
             else:
-                return formatted_transcription, "Summary not available", prettified_json_file_path, None, video_file_path, None
+                return formatted_transcription, summary_text, prettified_json_file_path, None, video_file_path, None
         else:
             return "No results found.", "Summary not available", None, None, None, None
     except Exception as e:
         return str(e), "Error processing the request.", None, None, None, None
 
 
-
-
 def create_download_directory(title):
     base_dir = "Results"
     # Remove characters that are illegal in Windows filenames and normalize
@@ -439,7 +441,6 @@ def get_youtube(video_url):
             return None
 
 
-
 def get_playlist_videos(playlist_url):
     ydl_opts = {
         'extract_flat': True,
@@ -826,6 +827,7 @@ def summarize_with_openai(api_key, file_path, model, custom_prompt):
         response = requests.post('https://api.openai.com/v1/chat/completions', headers=headers, json=data)
 
         if response.status_code == 200:
+            global summary
             summary = response.json()['choices'][0]['message']['content'].strip()
             logging.debug("openai: Summarization successful")
             print("Summarization successful.")
@@ -885,6 +887,7 @@ def summarize_with_claude(api_key, file_path, model, custom_prompt):
             logging.debug("anthropic: Post submittal successful")
             response_data = response.json()
             try:
+                global summary
                 summary = response_data['content'][0]['text'].strip()
                 logging.debug("anthropic: Summarization successful")
                 print("Summary processed successfully.")
@@ -945,8 +948,9 @@ def summarize_with_cohere(api_key, file_path, model, custom_prompt):
 
         if response.status_code == 200:
             if 'text' in response_data:
+                global summary
                 summary = response_data['text'].strip()
-                logging.debug("cohere: Summarization successful")
+                logging.debug(f"cohere: Summarization successful:\n\n{summary}\n\n")
                 print("Summary processed successfully.")
                 return summary
             else:
@@ -999,6 +1003,7 @@ def summarize_with_groq(api_key, file_path, model, custom_prompt):
 
         if response.status_code == 200:
             if 'choices' in response_data and len(response_data['choices']) > 0:
+                global summary
                 summary = response_data['choices'][0]['message']['content'].strip()
                 logging.debug("groq: Summarization successful")
                 print("Summarization successful.")
@@ -1051,6 +1056,7 @@ def summarize_with_llama(api_url, file_path, token, custom_prompt):
         if response.status_code == 200:
             # if 'X' in response_data:
             logging.debug(response_data)
+            global summary
             summary = response_data['content'].strip()
             logging.debug("llama: Summarization successful")
             print("Summarization successful.")
@@ -1100,6 +1106,7 @@ def summarize_with_kobold(kobold_ip, json_file_path, kobold_token, custom_prompt
 
         if response.status_code == 200:
             if 'results' in response_data and len(response_data['results']) > 0:
+                global summary
                 summary = response_data['results'][0]['text'].strip()
                 logging.debug("kobold: Summarization successful")
                 print("Summarization successful.")
@@ -1152,6 +1159,7 @@ def summarize_with_oobabooga(ooba_ip, json_file_path, ooba_token, custom_prompt)
 
         if response.status_code == 200:
             response_data = response.json()
+            global summary
             summary = response.json()['choices'][0]['message']['content']
             logging.debug("ooba: Summarization successful")
             print("Summarization successful.")
@@ -1185,35 +1193,22 @@ def save_summary_to_file(summary, file_path):
 # Only to be used when configured with Gradio for HF Space
 def summarize_with_huggingface(huggingface_api_key, json_file_path, custom_prompt):
     logging.debug(f"huggingface: Summarization process starting...")
+    client = InferenceClient()
 
-    model = "microsoft/Phi-3-mini-128k-instruct"
+    #model = "microsoft/Phi-3-mini-128k-instruct"
+    model = "CohereForAI/c4ai-command-r-plus"
     API_URL = f"https://api-inference.huggingface.co/models/{model}"
     headers = {"Authorization": f"Bearer {huggingface_api_key}"}
 
+    client = InferenceClient(model=f"{model}", token=f"{huggingface_api_key}")
+
+    response = client.post(json={"inputs": "The goal of life is [MASK]."}, model="bert-base-uncased")
+
     with open(json_file_path, 'r') as file:
         segments = json.load(file)
     text = ''.join([segment['text'] for segment in segments])
 
-    # FIXME adjust max_length and min_length as needed
-    data = {
-        "inputs": text + "\n\n\n\n" + custom_prompt,
-        "parameters": {"max_length": 4096, "min_length": 100}
-    }
-
-    max_retries = 5
-
-    for attempt in range(max_retries):
-        response = requests.post(API_URL, headers=headers, json=data)
-        if response.status_code == 200:
-            summary = response.json()[0]['summary_text']
-            return summary, None
-        elif response.status_code == 503:
-            response_data = response.json()
-            wait_time = response_data.get('estimated_time', 10)
-            return None, f"Model is loading, retrying in {int(wait_time)} seconds..."
-            # FIXME : This is a hack, should be done better
-            # Sleep before retrying....
-            # time.sleep(wait_time)
+    hf_prompt = text + "\n\n\n\n" + custom_prompt
 
     if huggingface_api_key == "":
         api_key = os.getenv(HF_TOKEN)
@@ -1230,17 +1225,22 @@ def summarize_with_huggingface(huggingface_api_key, json_file_path, custom_promp
         logging.debug("HUGGINGFACE API KEY CHECK #2: " + huggingface_api_key)
 
         logging.debug("huggingface: Submitting request...")
-        logging.debug("huggingface: Printing request headers: %s", headers)
-        response = requests.post(API_URL, headers=headers, json=data)
-
-        if response.status_code == 200:
-            summary = response.json()[0]['summary_text']
-            logging.debug("huggingface: Summarization successful")
-            print("Summarization successful.")
-            return summary
+        response = client.text_generation(prompt=hf_prompt, max_new_tokens=4096)
+        if response is not None:
+            return response
+        #if response == FIXME:
+            #logging.debug("huggingface: Summarization successful")
+            #print("Summarization successful.")
+            #return response
+        #elif Bad Stuff:
+            # logging.debug(f"huggingface: Model is currently loading...{response.status_code}: {response.text}")
+            # global waiting_summary
+            # pretty_json = json.dumps(json.loads(response.text), indent=4)  # Prettify JSON
+            # waiting_summary = f" {pretty_json} "  # Use prettified JSON
+            # return waiting_summary
         else:
-            logging.error(f"huggingface: Summarization failed with status code {response.status_code}: {response.text}")
-            return f"Failed to process summary, status code {response.status_code}: {response.text}"
+            logging.error(f"huggingface: Summarization failed with status code {response}")
+            return f"Failed to process summary, huggingface library error: {response}"
     except Exception as e:
         logging.error("huggingface: Error in processing: %s", str(e))
         print(f"Error occurred while processing summary with huggingface: {str(e)}")
@@ -1274,6 +1274,7 @@ def update_visibility(mode):
         # Hide all inputs below URL
         return [gr.update(visible=False)] * 9
 
+
 # https://www.gradio.app/guides/controlling-layout
 def launch_ui(demo_mode=False):
     whisper_models = ["small.en", "medium.en", "large"]
@@ -1307,7 +1308,8 @@ def launch_ui(demo_mode=False):
             offset_input = gr.Number(value=0, label="Offset (Seconds into the video to start transcribing at)",
                                      visible=False)
             api_name_input = gr.Dropdown(
-                choices=[None,"huggingface", "openai", "anthropic", "cohere", "groq", "llama", "kobold", "ooba"], value=None,
+                choices=[None, "huggingface", "openai", "anthropic", "cohere", "groq", "llama", "kobold", "ooba"],
+                value=None,
                 label="API Name (Mandatory Unless you just want a Transcription)", visible=True)
             api_key_input = gr.Textbox(label="API Key (Mandatory if API Name is specified)",
                                        placeholder="Enter your API key here", visible=True)
@@ -1370,6 +1372,7 @@ def launch_ui(demo_mode=False):
 
         iface.launch(share=False)
 
+
 #
 #
 #####################################################################################################################################
@@ -1442,18 +1445,33 @@ def main(input_path, api_name=None, api_key=None, num_speakers=2, whisper_model=
                 logging.info(f"Transcription complete: {audio_file}")
 
                 # Perform summarization based on the specified API
-                logging.debug(f"MAIN: HF: Summarization being performed by HuggingFace")
+                logging.debug(f"MAIN: Summarization being performed by {api_name} API")
                 json_file_path = audio_file.replace('.wav', '.segments.json')
                 if api_name == "huggingface":
                     huggingface_api_key = os.getenv('HF_TOKEN').replace('"', '')
                     if huggingface_api_key is None:
-                        huggingface_api_key = api_key if api_key else config.get('API', 'huggingface_api_key', fallback=None)
+                        huggingface_api_key = api_key if api_key else config.get('API', 'huggingface_api_key',
+                                                                                 fallback=None)
                     try:
                         logging.debug(f"MAIN: Trying to summarize with huggingface")
                         summarize_with_huggingface(huggingface_api_key, json_file_path, custom_prompt)
                     except requests.exceptions.ConnectionError:
                         requests.status_code = "Connection: "
-                if api_name and api_key:
+                elif api_name == "cohere":
+                    cohere_api_key = os.getenv('COHERE_TOKEN').replace('"', '')
+                    if cohere_api_key is None:
+                        cohere_api_key = api_key if api_key else config.get('API', 'cohere_api_key',
+                                                                                 fallback=None)
+                    try:
+                        global summary
+                        logging.debug(f"MAIN: Trying to summarize with Cohere on HuggingFace Spaces")
+                        summary = summarize_with_cohere(cohere_api_key, json_file_path, cohere_model, custom_prompt)
+                        transcription_result['summary'] = summary
+                        logging.info(f"Summary generated using {api_name} API")
+                        save_summary_to_file(summary, json_file_path)
+                    except requests.exceptions.ConnectionError:
+                        requests.status_code = "Connection: "
+                elif api_name and api_key:
                     logging.debug(f"MAIN: Summarization being performed by {api_name}")
                     json_file_path = audio_file.replace('.wav', '.segments.json')
                     if api_name.lower() == 'openai':
@@ -1466,17 +1484,20 @@ def main(input_path, api_name=None, api_key=None, num_speakers=2, whisper_model=
                     elif api_name.lower() == "huggingface":
                         huggingface_api_key = os.getenv(HF_TOKEN)
                         if huggingface_api_key is None:
-                            huggingface_api_key = api_key if api_key else config.get('API', 'huggingface_api_key', fallback=None)
+                            huggingface_api_key = api_key if api_key else config.get('API', 'huggingface_api_key',
+                                                                                     fallback=None)
                         try:
                             logging.debug(f"MAIN: Trying to summarize with huggingface")
                             summarize_with_huggingface(huggingface_api_key, json_file_path, custom_prompt)
                         except requests.exceptions.ConnectionError:
                             requests.status_code = "Connection: "
                     elif api_name.lower() == "anthropic":
-                        anthropic_api_key = api_key if api_key else config.get('API', 'anthropic_api_key', fallback=None)
+                        anthropic_api_key = api_key if api_key else config.get('API', 'anthropic_api_key',
+                                                                               fallback=None)
                         try:
                             logging.debug(f"MAIN: Trying to summarize with anthropic")
-                            summary = summarize_with_claude(anthropic_api_key, json_file_path, anthropic_model, custom_prompt)
+                            summary = summarize_with_claude(anthropic_api_key, json_file_path, anthropic_model,
+                                                            custom_prompt)
                         except requests.exceptions.ConnectionError:
                             requests.status_code = "Connection: "
                     elif api_name.lower() == "cohere":
@@ -1521,6 +1542,7 @@ def main(input_path, api_name=None, api_key=None, num_speakers=2, whisper_model=
                         logging.warning(f"Unsupported API: {api_name}")
                         summary = None
 
+                    print(f"MAIN: #1 - Summary: {summary}")
                     if summary:
                         transcription_result['summary'] = summary
                         logging.info(f"Summary generated using {api_name} API")