Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Correcting Supadata URL and Apify Endpoint/Logic)
+# main.py (Correcting SyntaxError at line 216)
 import os
 import re
 import logging
@@ -71,7 +71,7 @@ APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')
 WEBHOOK_SECRET = get_secret('WEBHOOK_SECRET')
 
 OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "deepseek/deepseek-chat-v3-0324:free")
-APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts") # Keep karamelo as per docs
+APIFY_ACTOR_ID = os.environ.get("APIFY_ACTOR_ID", "karamelo~youtube-transcripts") # Using ~ as per last attempt
 
 if not TELEGRAM_TOKEN: logger.critical("❌ FATAL: TELEGRAM_TOKEN not found."); raise RuntimeError("Exiting: Telegram token missing.")
 if not OPENROUTER_API_KEY: logger.error("❌ ERROR: OPENROUTER_API_KEY not found. Summarization will fail.")
@@ -132,8 +132,7 @@ async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[s
     if not video_id: logger.error("[Supadata] No video_id provided"); return None
     if not api_key: logger.error("[Supadata] API key missing."); return None
     logger.info(f"[Supadata] Attempting fetch for video ID: {video_id}")
-    # *** FIX: Use correct base URL ***
-    api_endpoint = "https://api.supadata.ai/v1/youtube/transcript"
+    api_endpoint = "https://api.supadata.ai/v1/youtube/transcript" # Corrected URL
     params = {"videoId": video_id, "format": "text"}; headers = {"X-API-Key": api_key}
     try:
         async with httpx.AsyncClient(timeout=30.0) as client:
@@ -145,7 +144,7 @@ async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[s
                     except json.JSONDecodeError: data = None
                     content = None
                     if data: content = data if isinstance(data, str) else data.get("transcript") or data.get("text") or data.get("data")
-                    if not content and response.text: content = response.text # Check plain text response
+                    if not content and response.text: content = response.text
                     if content and isinstance(content, str): logger.info(f"[Supadata] Success for {video_id}. Length: {len(content)}"); return content.strip()
                     else: logger.warning(f"[Supadata] Success but content empty/invalid for {video_id}. Response: {response.text[:200]}"); return None
                 except Exception as e: logger.error(f"[Supadata] Error processing success response for {video_id}: {e}", exc_info=True); return None
@@ -154,8 +153,7 @@ async def get_transcript_via_supadata(video_id: str, api_key: str) -> Optional[s
             else: logger.error(f"[Supadata] Unexpected status {response.status_code} for {video_id}. Resp: {response.text[:200]}"); return None
     except httpx.TimeoutException: logger.error(f"[Supadata] Timeout connecting for {video_id}"); return None
     except httpx.RequestError as e:
-        # SSL errors usually fall under RequestError
-        if "CERTIFICATE_VERIFY_FAILED" in str(e): logger.error(f"[Supadata] SSL Cert Verify Failed for {video_id}: {e}")
+        if "CERTIFICATE_VERIFY_FAILED" in str(e): logger.error(f"[Supadata] SSL Cert Verify Failed for {video_id}: {e}") # Should be fixed now
         else: logger.error(f"[Supadata] Request error for {video_id}: {e}")
         return None
     except Exception as e: logger.error(f"[Supadata] Unexpected error for {video_id}: {e}", exc_info=True); return None
@@ -167,44 +165,31 @@ async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[s
     if not api_token: logger.error("[Apify SyncItems] API token missing."); return None
     logger.info(f"[Apify SyncItems] Attempting fetch for URL: {video_url} (Actor: {APIFY_ACTOR_ID})")
 
-    # *** FIX: Use the run-sync-get-dataset-items endpoint ***
     sync_items_endpoint = f"https://api.apify.com/v2/acts/{APIFY_ACTOR_ID}/run-sync-get-dataset-items"
     params = {"token": api_token} # Token in param as per OpenAPI spec for this endpoint
-    payload = {
-        "urls": [video_url],
-        "outputFormat": "singleStringText",
-        "maxRetries": 5,
-        "channelHandleBoolean": False, "channelNameBoolean": False,
-        "datePublishedBoolean": False, "relativeDateTextBoolean": False,
-    }
+    payload = { "urls": [video_url], "outputFormat": "singleStringText", "maxRetries": 5, "channelHandleBoolean": False, "channelNameBoolean": False, "datePublishedBoolean": False, "relativeDateTextBoolean": False, }
     headers = {"Content-Type": "application/json"} # No Auth header needed if token in params
 
     try:
-        # Use a longer timeout for this synchronous endpoint
         async with httpx.AsyncClient(timeout=120.0) as client:
-            log_headers = {k: v for k, v in headers.items()} # Log headers
+            log_headers = {k: v for k, v in headers.items()}
             logger.debug(f"[Apify SyncItems] POST Request Details:\nURL: {sync_items_endpoint}\nParams: {params}\nHeaders: {log_headers}\nPayload: {json.dumps(payload)}")
-            # *** FIX: POST to the sync items endpoint ***
             response = await client.post(sync_items_endpoint, headers=headers, params=params, json=payload)
             logger.debug(f"[Apify SyncItems] Received status code {response.status_code} for {video_url}")
 
-            # *** FIX: Expect 200 OK for this endpoint ***
             if response.status_code == 200:
                 try:
-                    # Response body *is* the dataset items array
                     results = response.json()
                     if isinstance(results, list) and len(results) > 0:
                         item = results[0]
-                        # Parsing logic (same as before)
                         content = None
-                        if "captions" in item and isinstance(item["captions"], str): content = item["captions"]
-                        elif "text" in item and isinstance(item["text"], str): content = item["text"]
-                        elif "transcript" in item and isinstance(item["transcript"], str): content = item["transcript"]
+                        if "captions" in item and isinstance(item["captions"], str): logger.info("[Apify SyncItems] Found 'captions' key with string content."); content = item["captions"]
+                        elif "text" in item and isinstance(item["text"], str): logger.info("[Apify SyncItems] Found 'text' key with string content."); content = item["text"]
+                        elif "transcript" in item and isinstance(item["transcript"], str): logger.info("[Apify SyncItems] Found 'transcript' key with string content."); content = item["transcript"]
                         elif "captions" in item and isinstance(item["captions"], list):
                              logger.warning("[Apify SyncItems] Received list format for 'captions' unexpectedly. Processing...")
                              if len(item["captions"]) > 0 and isinstance(item["captions"][0], dict) and 'text' in item["captions"][0]: content = " ".join(line.get("text", "") for line in item["captions"] if line.get("text"))
                              elif len(item["captions"]) > 0 and isinstance(item["captions"][0], str): content = " ".join(item["captions"])
-
                         if content and isinstance(content, str): logger.info(f"[Apify SyncItems] Success via REST for {video_url}. Length: {len(content)}"); return content.strip()
                         else: logger.warning(f"[Apify SyncItems] Dataset item parsed but transcript content empty/invalid format for {video_url}. Item keys: {list(item.keys())}"); return None
                     else: logger.warning(f"[Apify SyncItems] Actor success but dataset was empty for {video_url}. Response: {results}"); return None
@@ -212,7 +197,7 @@ async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[s
                 except Exception as e: logger.error(f"[Apify SyncItems] Error processing success response for {video_url}: {e}", exc_info=True); return None
             elif response.status_code == 400: logger.error(f"[Apify SyncItems] Bad Request (400) for {video_url}. Check payload. Resp:{response.text[:200]}"); return None
             elif response.status_code == 401: logger.error("[Apify SyncItems] Auth error (401). Check token."); return None
-            elif response.status_code == 404: # This was the error before, log details if it happens again
+            elif response.status_code == 404:
                  error_info = ""; try: error_info = response.json().get("error", {}).get("message", "") except Exception: pass
                  logger.error(f"[Apify SyncItems] Endpoint/Actor Not Found (404). Error: '{error_info}' Resp:{response.text[:200]}"); return None
             else: logger.error(f"[Apify SyncItems] Unexpected status {response.status_code} for {video_url}. Resp:{response.text[:200]}"); return None
@@ -223,7 +208,7 @@ async def get_transcript_via_apify(video_url: str, api_token: str) -> Optional[s
     except Exception as e: logger.error(f"[Apify SyncItems] Unexpected error during Apify SyncItems REST call for {video_url}: {e}", exc_info=True); return None
 
 
-# (get_youtube_transcript, get_website_content, get_website_content_via_api, generate_summary remain the same)
+# (get_youtube_transcript, get_website_content, get_website_content_via_api remain the same)
 async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]:
     global SUPADATA_API_KEY, APIFY_API_TOKEN
     if not video_id: logger.error("get_youtube_transcript: No video_id"); return None
@@ -248,9 +233,9 @@ async def get_youtube_transcript(video_id: str, video_url: str) -> Optional[str]
             else: logger.warning(f"[Fallback YT 1] Supadata failed or no content for {video_id}.")
         else: logger.warning("[Fallback YT 1] Supadata API key unavailable. Skipping.")
     if transcript_text is None:
-        logger.info("[Fallback YT 2] Trying Apify REST API (SyncItems)...") # Updated log
+        logger.info("[Fallback YT 2] Trying Apify REST API (SyncItems)...")
         if APIFY_API_TOKEN:
-            transcript_text = await get_transcript_via_apify(video_url, APIFY_API_TOKEN) # Calls updated func
+            transcript_text = await get_transcript_via_apify(video_url, APIFY_API_TOKEN)
             if transcript_text: logger.info(f"[Fallback YT 2] Success via Apify SyncItems REST for {video_url}"); return transcript_text
             else: logger.warning(f"[Fallback YT 2] Apify SyncItems REST failed or no content for {video_url}.")
         else: logger.warning("[Fallback YT 2] Apify API token unavailable. Skipping.")
@@ -305,7 +290,7 @@ async def get_website_content_via_api(url: str, api_key: str) -> Optional[str]:
     except httpx.RequestError as e: logger.error(f"[Fallback Web API] Request error connecting to urltotext.com API for {url}: {e}"); return None
     except Exception as e: logger.error(f"[Fallback Web API] Unexpected error during urltotext.com API call for {url}: {e}", exc_info=True); return None
 
-
+# --- Summarization Function ---
 async def generate_summary(text: str, summary_type: str) -> str:
     global OPENROUTER_API_KEY, OPENROUTER_MODEL
     logger.info(f"Generating {summary_type} summary using {OPENROUTER_MODEL}. Input length: {len(text)}")
@@ -340,7 +325,15 @@ async def generate_summary(text: str, summary_type: str) -> str:
             elif response.status_code == 402: logger.error("OpenRouter Payment Required (402)."); return "Sorry, AI service limits/payment issue."
             elif response.status_code == 429: logger.warning("OpenRouter Rate Limit Exceeded (429)."); return "Sorry, AI model is busy. Try again."
             elif response.status_code == 500: logger.error(f"OpenRouter Internal Server Error (500). Resp:{response.text[:500]}"); return "Sorry, AI service internal error."
-            else: logger.error(f"Unexpected status {response.status_code} from OpenRouter. Resp:{response.text[:500]}"); return f"Sorry, AI service returned unexpected status ({response.status_code})."
+            else:
+                # *** FIX: Corrected Indentation for error info extraction ***
+                error_info = ""
+                try:
+                    error_info = response.json().get("error", {}).get("message", "")
+                except Exception:
+                    pass
+                logger.error(f"Unexpected status {response.status_code} from OpenRouter. Error: '{error_info}' Resp:{response.text[:500]}");
+                return f"Sorry, AI service returned unexpected status ({response.status_code})."
     except httpx.ReadTimeout: logger.error(f"Read Timeout error ({api_timeouts.read}s) waiting for OpenRouter API response."); return f"Sorry, the request to the AI model timed out after {api_timeouts.read} seconds while waiting for a response. The content might be too long or the service busy. Please try again later or with shorter content."
     except httpx.TimeoutException as e: logger.error(f"Timeout error ({type(e)}) connecting to/writing to OpenRouter API: {e}"); return "Sorry, the request to the AI model timed out. Please try again."
     except httpx.RequestError as e: logger.error(f"Request error connecting to OpenRouter API: {e}"); return "Sorry, there was an error connecting to the AI model service."
@@ -349,7 +342,7 @@ async def generate_summary(text: str, summary_type: str) -> str:
         if response: logger.error(f"--> Last response status before error: {response.status_code}")
         return "Sorry, an unexpected error occurred while trying to generate the summary."
 
-
+# (process_summary_task, handlers, setup, lifespan, routes, etc. remain the same)
 async def process_summary_task( user_id: int, chat_id: int, message_id_to_edit: Optional[int], url: str, summary_type: str, bot_token: str ) -> None:
     task_id = f"{user_id}-{message_id_to_edit or 'new'}"; logger.info(f"[Task {task_id}] Starting processing for URL: {url}")
     background_request: Optional[BaseRequest] = None; bot: Optional[Bot] = None