Update app.py

app.py

@@ -731,9 +731,32 @@ def solve_optimal_alignment(original_segments, generated_durations, total_durati
 #     merged = sorted(merged, key=lambda x: x["start"])
 
 #     return merged
+# --- Function Definitions ---
+
+def process_segment_with_gpt(segment, source_lang, target_lang, model="gpt-4", openai_client=None):
+    """
+    Processes a single text segment: restores punctuation and translates using an OpenAI GPT model.
+    """
+    # Essential check: Ensure the OpenAI client is provided
+    if openai_client is None:
+        segment_identifier = f"{segment.get('start', 'N/A')}-{segment.get('end', 'N/A')}"
+        logger.error(f"❌ OpenAI client was not provided for segment {segment_identifier}. Cannot process.")
+        return {
+            "start": segment.get("start"),
+            "end": segment.get("end"),
+            "speaker": segment.get("speaker", "SPEAKER_00"),
+            "original": segment["text"],
+            "translated": "[ERROR: OpenAI client not provided]"
+        }
 
-def process_segment_with_gpt(segment, source_lang, target_lang, model="gpt-4"):
     original_text = segment["text"]
+    segment_id = f"{segment['start']}-{segment['end']}" # Create a unique ID for this segment for easier log tracking
+
+    logger.debug(
+        f"Starting processing for segment {segment_id}. "
+        f"Original text preview: '{original_text[:100]}{'...' if len(original_text) > 100 else ''}'"
+    )
+
     prompt = (
         f"You are a multilingual assistant. Given the following text in {source_lang}, "
         f"1) restore punctuation, and 2) translate it into {target_lang}.\n\n"
@@ -743,39 +766,111 @@ def process_segment_with_gpt(segment, source_lang, target_lang, model="gpt-4"):
     )
 
     try:
-        response = client.chat.completions.create(
+        logger.debug(f"Sending request to OpenAI model '{model}' for segment {segment_id}...")
+        response = openai_client.chat.completions.create( # Using the passed 'openai_client'
             model=model,
             messages=[{"role": "user", "content": prompt}],
             temperature=0.3
         )
         content = response.choices[0].message.content.strip()
-        result_json = eval(content) if content.startswith("{") else {}
+        logger.debug(
+            f"Received raw response from model for segment {segment_id}: "
+            f"'{content[:200]}{'...' if len(content) > 200 else ''}'" # Truncate for log readability
+        )
+
+        result_json = {}
+        try:
+            # Use json.loads for safer and standard JSON parsing compared to eval()
+            result_json = json.loads(content)
+        except json.JSONDecodeError as e:
+            logger.warning(
+                f"⚠️ Failed to parse JSON response for segment {segment_id}. Error: {e}. "
+                f"Raw content received: '{content}'"
+            )
+            # Fallback behavior if JSON parsing fails: use original text, empty translation
+            punctuated_text = original_text
+            translated_text = ""
+        else:
+            # If JSON parsing was successful
+            punctuated_text = result_json.get("punctuated", original_text)
+            translated_text = result_json.get("translated", "")
 
+        logger.info(
+            f"✅ Successfully processed segment {segment_id}. "
+            f"Punctuated preview: '{punctuated_text[:50]}{'...' if len(punctuated_text) > 50 else ''}', "
+            f"Translated preview: '{translated_text[:50]}{'...' if len(translated_text) > 50 else ''}'"
+        )
         return {
             "start": segment["start"],
             "end": segment["end"],
             "speaker": segment.get("speaker", "SPEAKER_00"),
-            "original": result_json.get("punctuated", original_text),
-            "translated": result_json.get("translated", "")
+            "original": punctuated_text,
+            "translated": translated_text
         }
-
     except Exception as e:
-        print(f"❌ Error for segment {segment['start']}-{segment['end']}: {e}")
+        # Log the full traceback using exc_info=True for better debugging
+        logger.error(
+            f"❌ An unexpected error occurred while processing segment {segment_id}: {e}",
+            exc_info=True
+        )
+        # Return the original segment with an empty translated text on error
         return {
             "start": segment["start"],
             "end": segment["end"],
             "speaker": segment.get("speaker", "SPEAKER_00"),
             "original": original_text,
-            "translated": ""
+            "translated": "[ERROR: Processing failed]"
         }
 
-def punctuate_and_translate_parallel(transcription_json, source_lang="zh", target_lang="en", model="gpt-4o", max_workers=5):
+def punctuate_and_translate_parallel(transcription_json, source_lang="zh", target_lang="en", model="gpt-4o", max_workers=5, openai_client=None):
+    """
+    Orchestrates parallel punctuation restoration and translation of multiple segments
+    using a ThreadPoolExecutor.
+    """
+    if not transcription_json:
+        logger.warning("No segments provided in transcription_json for parallel processing. Returning an empty list.")
+        return []
+
+    logger.info(f"Starting parallel punctuation and translation for {len(transcription_json)} segments.")
+    logger.info(
+        f"Configuration: Model='{model}', Source Language='{source_lang}', "
+        f"Target Language='{target_lang}', Max Workers={max_workers}."
+    )
+
+    results = []
     with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures = [
-            executor.submit(process_segment_with_gpt, seg, source_lang, target_lang, model)
+        # Submit each segment for processing, ensuring the openai_client is passed to each worker
+        futures = {
+            executor.submit(process_segment_with_gpt, seg, source_lang, target_lang, model, openai_client): seg
             for seg in transcription_json
-        ]
-        return [f.result() for f in concurrent.futures.as_completed(futures)]
+        }
+        logger.info(f"All {len(futures)} segments have been submitted to the thread pool.")
+
+        # Asynchronously collect results as they complete
+        for i, future in enumerate(concurrent.futures.as_completed(futures)):
+            segment = futures[future] # Retrieve the original segment data for logging context
+            segment_id = f"{segment['start']}-{segment['end']}"
+            try:
+                result = future.result() # This will re-raise any exception from the worker thread
+                results.append(result)
+                logger.debug(f"Collected result for segment {segment_id}. ({i + 1}/{len(futures)} completed)")
+            except Exception as exc:
+                # This catch block is for rare cases where the future itself fails to yield a result,
+                # or an exception was not caught within `process_segment_with_gpt`.
+                logger.error(
+                    f"Unhandled exception encountered while retrieving result for segment {segment_id}: {exc}",
+                    exc_info=True
+                )
+                # Ensure a placeholder result is added even if future retrieval fails
+                results.append({
+                    "start": segment.get("start"),
+                    "end": segment.get("end"),
+                    "speaker": segment.get("speaker", "SPEAKER_00"),
+                    "original": segment["text"],
+                    "translated": "[ERROR: Unhandled exception in parallel processing]"
+                })
+    logger.info("🎉 Parallel processing complete. All results collected.")
+    return results
         
 # def merge_speaker_and_time_from_whisperx(ocr_json, whisperx_json, text_sim_threshold=80, replace_threshold=90):
 #     merged = []