Update app.py

app.py

@@ -9,15 +9,14 @@ import base64
 from concurrent.futures import ThreadPoolExecutor
 from PIL import Image, ImageOps
 
+
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
 import rarfile
 import zipfile
-
-# --- MIGRATION: New SDK Imports ---
-from google import genai
-from google.genai import types
+import google.generativeai as genai
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -52,112 +51,49 @@ def parse_filename_to_ms(filename):
     return (h * 3600000) + (m * 60000) + (s * 1000) + ms
 
 def parse_srt(content: str):
-    """
-    Robust State Machine Parser for SRT (Backend Version).
-    Matches Frontend logic to handle blank subtitles correctly.
-    """
+    # Normalize line endings
     content = content.replace('\r\n', '\n').replace('\r', '\n')
-    lines = content.split('\n')
+    # Split by double newline (standard SRT block separator)
+    blocks = re.split(r'\n\n+', content.strip())
     
     parsed = []
-    current_item = {"id": None, "time": None, "text_lines": []}
-    state = 'SEARCH_ID' # States: SEARCH_ID, SEARCH_TIME, READ_TEXT
-
-    for i, line in enumerate(lines):
-        line = line.strip()
-        next_line = lines[i+1].strip() if i + 1 < len(lines) else None
-        
-        if state == 'SEARCH_ID':
-            if line.isdigit():
-                current_item["id"] = line
-                state = 'SEARCH_TIME'
-        
-        elif state == 'SEARCH_TIME':
-            if '-->' in line:
-                current_item["time"] = line
-                state = 'READ_TEXT'
-                
-                # EDGE CASE: Immediate Blank Subtitle
-                # If next line is a number (start of new ID), current block is blank
-                if next_line and next_line.isdigit():
-                    # Check 2 lines ahead to confirm it's really an ID (followed by timestamp)
-                    line_after_next = lines[i+2].strip() if i + 2 < len(lines) else None
-                    if line_after_next and '-->' in line_after_next:
-                        # Close current blank block
-                        start_ms = parse_srt_time_to_ms(current_item["time"].split('-->')[0].strip())
-                        parsed.append({
-                            "id": current_item["id"],
-                            "time": current_item["time"],
-                            "startTimeMs": start_ms,
-                            "text": ""
-                        })
-                        current_item = {"id": None, "time": None, "text_lines": []}
-                        state = 'SEARCH_ID'
-            elif line.isdigit():
-                # Recover from missing timestamp
-                current_item["id"] = line
+    for block in blocks:
+        lines = [l.strip() for l in block.split('\n') if l.strip()]
+        if len(lines) < 2:
+            continue
+            
+        srt_id = lines[0]
+        time_range = lines[1]
         
-        elif state == 'READ_TEXT':
-            # Check for start of new block (ID line followed by Time line)
-            is_new_block_start = (
-                line.isdigit() and 
-                next_line and '-->' in next_line
-            )
+        # Check if there is actually text after the timestamp
+        # If there are lines after index 1, join them; otherwise, it's a blank sub
+        if len(lines) > 2:
+            text = "\n".join(lines[2:])
+        else:
+            text = "" # Explicitly blank
             
-            # Check for standard blank line separator
-            is_blank_separator = (
-                line == '' and 
-                next_line and next_line.isdigit() and 
-                (i + 2 < len(lines) and '-->' in lines[i+2])
-            )
-
-            if is_new_block_start:
-                # Missing blank separator, force close
-                text = "\n".join(current_item["text_lines"]).strip() or ""
-                start_ms = parse_srt_time_to_ms(current_item["time"].split('-->')[0].strip())
-                parsed.append({
-                    "id": current_item["id"],
-                    "time": current_item["time"],
-                    "startTimeMs": start_ms,
-                    "text": text
-                })
-                current_item = {"id": line, "time": None, "text_lines": []}
-                state = 'SEARCH_TIME'
+        try:
+            start_time_str = time_range.split('-->')[0].strip()
+            start_ms = parse_srt_time_to_ms(start_time_str)
             
-            elif is_blank_separator:
-                # Standard closure
-                text = " ".join(current_item["text_lines"]).strip() or "[BLANK SUBTITLE]"
-                start_ms = parse_srt_time_to_ms(current_item["time"].split('-->')[0].strip())
-                parsed.append({
-                    "id": current_item["id"],
-                    "time": current_item["time"],
-                    "startTimeMs": start_ms,
-                    "text": text
-                })
-                current_item = {"id": None, "time": None, "text_lines": []}
-                state = 'SEARCH_ID'
+            parsed.append({
+                "id": srt_id,
+                "time": time_range,
+                "startTimeMs": start_ms,
+                "text": text
+            })
+        except Exception as e:
+            logger.warning(f"Skipping malformed SRT block: {block[:50]}... Error: {e}")
             
-            else:
-                if line:
-                    current_item["text_lines"].append(line)
-
-    # Push last item
-    if current_item["id"] and current_item["time"]:
-        text = " ".join(current_item["text_lines"]).strip() or "[BLANK SUBTITLE]"
-        start_ms = parse_srt_time_to_ms(current_item["time"].split('-->')[0].strip())
-        parsed.append({
-            "id": current_item["id"],
-            "time": current_item["time"],
-            "startTimeMs": start_ms,
-            "text": text
-        })
-
     return parsed
 
 
+logger = logging.getLogger(__name__)
+
 def compress_image(image_bytes, max_width=800, quality=80):
     """
     Compresses an image to WebP (best) or optimized JPEG.
+    Renamed back to 'compress_image' to fix your error.
     """
     try:
         img = Image.open(io.BytesIO(image_bytes))
@@ -168,6 +104,7 @@ def compress_image(image_bytes, max_width=800, quality=80):
         buffer = io.BytesIO()
 
         # 2. Try WebP first (Best quality/size ratio)
+        # If you strictly need JPEG, change use_webp to False
         use_webp = True 
         
         if use_webp:
@@ -199,14 +136,14 @@ def compress_image(image_bytes, max_width=800, quality=80):
 
     except Exception as e:
         logger.error(f"Image compression failed: {e}")
+        # If logging isn't setup, print the error so you can see it
+        print(f"Error: {e}")
         return None
 
-# --- MIGRATION: Updated Gemini Processing Function ---
 def process_batch_gemini(api_key, items, model_name):
     try:
-        # 1. Instantiate the Client (New SDK pattern)
-        # This replaces genai.configure()
-        client = genai.Client(api_key=api_key)
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel(model_name)
 
         prompt_parts = [
             "You are a Subtitle Quality Control (QC) bot.",
@@ -221,18 +158,13 @@ def process_batch_gemini(api_key, items, model_name):
             prompt_parts.append(f"Index: {item['index']}")
             prompt_parts.append(f"Expected Text: \"{item['expected_text']}\"")
             prompt_parts.append(f"Image:")
-            
-            # The new SDK handles PIL images directly in the contents list just like the old one
             img = Image.open(io.BytesIO(item['image_data']))
             prompt_parts.append(img)
 
-        # 2. Call generate_content via the client
-        response = client.models.generate_content(
-            model=model_name,
-            contents=prompt_parts,
-            config=types.GenerateContentConfig(
-                response_mime_type="application/json"
-            )
+        # Enforce JSON mode
+        response = model.generate_content(
+            prompt_parts,
+            generation_config={"response_mime_type": "application/json"}
         )
         
         text = response.text.replace("```json", "").replace("```", "").strip()
@@ -241,6 +173,7 @@ def process_batch_gemini(api_key, items, model_name):
             return json.loads(text)
         except json.JSONDecodeError as e:
             # Handle Truncated JSON (Output Token Limit Exceeded)
+            # This happens if the batch size is too large for the model's output window
             logger.warning(f"JSON Parse Error (likely truncated response): {e}. Attempting repair...")
             
             # Repair Strategy: Find the last closing brace '}', discard everything after, and close the array ']'
@@ -268,7 +201,7 @@ async def analyze_subtitles(
     media_files: list[UploadFile] = File(...),
     api_keys: str = Form(...),
     batch_size: int = Form(20),
-    model_name: str = Form("gemini-2.0-flash"), # Updated default model hint
+    model_name: str = Form("gemini-3-flash-preview"),
     compression_quality: float = Form(0.7)
 ):
     temp_dir = tempfile.mkdtemp()