Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Revised: Starlette Lifespan for PTB Initialization)
+# main.py (Revised: Starlette Lifespan + ptb_app._running fix)
 import os
 import re
 import logging
@@ -24,7 +24,7 @@ from telegram.ext import (
     CallbackQueryHandler,
 )
 from telegram.constants import ParseMode
-from telegram.error import NetworkError # For specific error handling if needed
+from telegram.error import NetworkError, RetryAfter # Import RetryAfter
 
 # --- Other Libraries ---
 from youtube_transcript_api import YouTubeTranscriptApi
@@ -47,8 +47,8 @@ logging.getLogger("telegram.ext").setLevel(logging.INFO)
 logging.getLogger('telegram.bot').setLevel(logging.INFO)
 logging.getLogger("urllib3").setLevel(logging.INFO)
 logging.getLogger('gunicorn.error').setLevel(logging.INFO)
-logging.getLogger('uvicorn').setLevel(logging.INFO) # Uvicorn logs (incl. access)
-logging.getLogger('starlette').setLevel(logging.INFO) # Starlette logs
+logging.getLogger('uvicorn').setLevel(logging.INFO)
+logging.getLogger('starlette').setLevel(logging.INFO)
 logger = logging.getLogger(__name__)
 logger.info("Logging configured.")
 
@@ -180,7 +180,6 @@ async def get_transcript_via_apify(video_url: str, api_token: str):
                     item = results[0]
                     content = item.get("text") or item.get("transcript") or item.get("captions_concatenated")
 
-                    # --- !!! FIXED FALLBACK LOGIC !!! ---
                     if not content and item.get("captions"):
                         captions_data = item["captions"]
                         if isinstance(captions_data, str):
@@ -202,179 +201,135 @@ async def get_transcript_via_apify(video_url: str, api_token: str):
                                content = html.unescape(content) # Use imported html module
                            except Exception as unescape_err:
                                logger.warning(f"[Apify] Error during html unescaping: {unescape_err}")
-                    # --- !!! END FIXED FALLBACK LOGIC !!! ---
 
                     if content and isinstance(content, str):
                         logger.info(f"[Apify] Successfully fetched transcript via run-sync for {video_url} (Status: {response.status_code}). Length: {len(content)}")
-                        return content # Already stripped
+                        return content
                     else:
-                        # Log more clearly why content is None here
-                        if item.get("text") or item.get("transcript") or item.get("captions_concatenated"):
-                           logger.warning(f"[Apify] Actor run successful ({response.status_code}) but primary content fields were empty/None for {video_url}.")
-                        elif not item.get("captions"):
-                            logger.warning(f"[Apify] Actor run successful ({response.status_code}) but no text/transcript/captions_concatenated/captions field found for {video_url}. Item: {item}")
-                        else:
-                            logger.warning(f"[Apify] Actor run successful ({response.status_code}), 'captions' field found but fallback parsing failed to extract content for {video_url}.")
+                        if item.get("text") or item.get("transcript") or item.get("captions_concatenated"): logger.warning(f"[Apify] Actor success ({response.status_code}) but primary fields empty for {video_url}.")
+                        elif not item.get("captions"): logger.warning(f"[Apify] Actor success ({response.status_code}) but no relevant fields found for {video_url}. Item: {item}")
+                        else: logger.warning(f"[Apify] Actor success ({response.status_code}), 'captions' found but fallback parsing failed for {video_url}.")
                         return None
                 else:
-                    logger.warning(f"[Apify] Actor run successful ({response.status_code}) but dataset result list empty for {video_url}. Response: {results}")
+                    logger.warning(f"[Apify] Actor success ({response.status_code}) but dataset result list empty for {video_url}. Response: {results}")
                     return None
             except json.JSONDecodeError:
-                logger.error(f"[Apify] Failed to decode JSON response for {video_url}. Status: {response.status_code}. Resp: {response.text[:200]}...")
+                logger.error(f"[Apify] Failed JSON decode for {video_url}. Status: {response.status_code}. Resp: {response.text[:200]}...")
                 return None
             except Exception as e:
                 logger.error(f"[Apify] Error processing successful response ({response.status_code}) for {video_url}: {e}", exc_info=True)
                 return None
-        elif response.status_code == 400:
-             logger.error(f"[Apify] Bad Request (400) for {video_url}. Check payload. Response: {response.text[:200]}...")
-             return None
-        elif response.status_code == 401:
-            logger.error("[Apify] Authentication error (401). Check API token.")
-            return None
-        else:
-             logger.error(f"[Apify] Unexpected status code {response.status_code} from Apify API for {video_url}. Response: {response.text[:200]}...")
-             return None
+        elif response.status_code == 400: logger.error(f"[Apify] Bad Request (400) for {video_url}. Resp: {response.text[:200]}..."); return None
+        elif response.status_code == 401: logger.error("[Apify] Auth error (401). Check token."); return None
+        else: logger.error(f"[Apify] Unexpected status {response.status_code} for {video_url}. Resp: {response.text[:200]}..."); return None
 
-    except requests.exceptions.Timeout:
-        logger.error(f"[Apify] Timeout error running actor for {video_url}")
-        return None
-    except requests.exceptions.RequestException as e:
-        logger.error(f"[Apify] Request error running actor for {video_url}: {e}")
-        return None
-    except Exception as e:
-        logger.error(f"[Apify] Unexpected error during Apify call for {video_url}: {e}", exc_info=True)
-        return None
+    except requests.exceptions.Timeout: logger.error(f"[Apify] Timeout error running actor for {video_url}"); return None
+    except requests.exceptions.RequestException as e: logger.error(f"[Apify] Request error running actor for {video_url}: {e}"); return None
+    except Exception as e: logger.error(f"[Apify] Unexpected error during Apify call for {video_url}: {e}", exc_info=True); return None
 
-# Combined YouTube Transcript Function (with Fallbacks)
+# Combined YouTube Transcript Function
 async def get_youtube_transcript(video_id: str, video_url: str, supadata_key: str | None, apify_token: str | None):
     """Fetches YouTube transcript using library, then Supadata, then Apify."""
     if not video_id: logger.error("get_youtube_transcript called with no video_id"); return None
     logger.info(f"Fetching transcript for video ID: {video_id} (URL: {video_url})")
     transcript_text = None
-    try: # Wrap primary method in try/except
+    try: # Primary: Library
         logger.info("[Primary YT] Attempting youtube-transcript-api...")
-        transcript_list = await asyncio.to_thread(
-            YouTubeTranscriptApi.get_transcript,
-            video_id,
-            languages=['en', 'en-GB', 'en-US']
-        )
+        transcript_list = await asyncio.to_thread(YouTubeTranscriptApi.get_transcript, video_id, languages=['en', 'en-GB', 'en-US'])
         if transcript_list:
             transcript_text = " ".join([item['text'] for item in transcript_list if 'text' in item])
             transcript_text = re.sub(r'\s+', ' ', transcript_text).strip()
-            if transcript_text:
-                logger.info(f"[Primary YT] Successfully fetched transcript via library for {video_id} (length: {len(transcript_text)})")
-                return transcript_text
-            else:
-                 logger.warning(f"[Primary YT] Joined transcript text is empty after cleaning for {video_id}")
-                 transcript_text = None
-        else:
-            logger.warning(f"[Primary YT] Transcript list was empty for {video_id}")
-            transcript_text = None
+            if transcript_text: logger.info(f"[Primary YT] Success via library. Length: {len(transcript_text)}"); return transcript_text
+            else: logger.warning("[Primary YT] Joined text empty after cleaning."); transcript_text = None
+        else: logger.warning("[Primary YT] Transcript list empty."); transcript_text = None
     except Exception as e:
-        logger.warning(f"[Primary YT] Error getting transcript via library for {video_id}: {type(e).__name__} - {e}")
-        if "YouTube is blocking requests" in str(e) or "HTTP Error 429" in str(e): logger.warning("[Primary YT] IP likely blocked by YouTube (Rate Limit / Cloud IP).")
-        elif "No transcript found" in str(e): logger.warning(f"[Primary YT] No transcript available in specified languages for {video_id}.")
-        elif "TranscriptsDisabled" in str(e) or "disabled" in str(e): logger.warning(f"[Primary YT] Transcripts are disabled for {video_id}.")
+        logger.warning(f"[Primary YT] Error via library: {type(e).__name__} - {e}")
+        if "YouTube is blocking requests" in str(e) or "HTTP Error 429" in str(e): logger.warning("[Primary YT] IP likely blocked.")
+        elif "No transcript found" in str(e): logger.warning("[Primary YT] No transcript in languages.")
+        elif "TranscriptsDisabled" in str(e) or "disabled" in str(e): logger.warning("[Primary YT] Transcripts disabled.")
         transcript_text = None
 
     if transcript_text is None: # Fallback 1: Supadata
-        logger.info("[Fallback YT 1] Primary method failed or yielded no text. Trying Supadata API...")
+        logger.info("[Fallback YT 1] Trying Supadata API...")
         if supadata_key:
             transcript_text = await get_transcript_via_supadata(video_id, supadata_key)
-            if transcript_text:
-                logger.info(f"[Fallback YT 1] Successfully fetched transcript via Supadata for {video_id} (length: {len(transcript_text)})")
-                return transcript_text
-            else: logger.warning(f"[Fallback YT 1] Supadata API failed or returned no content for {video_id}.")
-        else: logger.warning("[Fallback YT 1] Supadata API key not available. Skipping.")
+            if transcript_text: logger.info(f"[Fallback YT 1] Success via Supadata. Length: {len(transcript_text)}"); return transcript_text
+            else: logger.warning("[Fallback YT 1] Supadata failed or no content.")
+        else: logger.warning("[Fallback YT 1] Supadata key not available.")
 
     if transcript_text is None: # Fallback 2: Apify
-        logger.info("[Fallback YT 2] Primary & Supadata failed or yielded no text. Trying Apify API...")
+        logger.info("[Fallback YT 2] Trying Apify API...")
         if apify_token:
             transcript_text = await get_transcript_via_apify(video_url, apify_token)
-            if transcript_text:
-                logger.info(f"[Fallback YT 2] Successfully fetched transcript via Apify for {video_url} (length: {len(transcript_text)})")
-                return transcript_text
-            else: logger.warning(f"[Fallback YT 2] Apify API failed or returned no content for {video_url}.")
-        else: logger.warning("[Fallback YT 2] Apify API token not available. Skipping.")
-
-    if transcript_text is None:
-        logger.error(f"All methods failed to fetch transcript for video ID: {video_id}")
-        return None
-    return transcript_text # Should technically be unreachable if logic is correct
+            if transcript_text: logger.info(f"[Fallback YT 2] Success via Apify. Length: {len(transcript_text)}"); return transcript_text
+            else: logger.warning("[Fallback YT 2] Apify failed or no content.")
+        else: logger.warning("[Fallback YT 2] Apify token not available.")
+
+    if transcript_text is None: logger.error(f"All methods failed for video ID: {video_id}")
+    return transcript_text
 
 # Website Content via Requests/BS4
 async def get_website_content_via_requests(url):
     """Attempts to scrape website content using requests/BeautifulSoup."""
-    if not url: logger.error("[Web Scraper - Requests/BS4] called with no URL"); return None
-    logger.info(f"[Web Scraper - Requests/BS4] Fetching website content for: {url}")
+    if not url: logger.error("[Web Scraper - Requests/BS4] no URL"); return None
+    logger.info(f"[Web Scraper - Requests/BS4] Fetching: {url}")
     try:
         headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8','Accept-Language': 'en-US,en;q=0.9','Connection': 'keep-alive','DNT': '1','Upgrade-Insecure-Requests': '1'}
-        logger.debug(f"[Web Scraper - Requests/BS4] Sending GET request to {url}")
         response = await asyncio.to_thread(requests.get, url, headers=headers, timeout=25, allow_redirects=True)
         response.raise_for_status()
-        logger.debug(f"[Web Scraper - Requests/BS4] Received response {response.status_code} from {url}")
+        logger.debug(f"[Web Scraper - Requests/BS4] Status {response.status_code} for {url}")
         content_type = response.headers.get('content-type', '').lower()
         if 'html' not in content_type:
-            logger.warning(f"[Web Scraper - Requests/BS4] Non-HTML content type received: {content_type}. Trying plain text.")
+            logger.warning(f"[Web Scraper - Requests/BS4] Non-HTML: {content_type}. Plain text?")
             if 'text/plain' in content_type and response.text: return response.text.strip()
             return None
         soup = BeautifulSoup(response.text, 'html.parser')
         for element in soup(["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "label", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "video", "audio"]): element.extract()
         main_content = soup.find('main') or soup.find('article') or soup.find(id='content') or soup.find(class_='content') or soup.find(id='main-content') or soup.find(class_='main-content') or soup.find(role='main')
         target_element = main_content if main_content else soup.body
-        if not target_element:
-            logger.warning(f"[Web Scraper - Requests/BS4] Could not find body or main content for {url}")
-            return None
+        if not target_element: logger.warning(f"[Web Scraper - Requests/BS4] No body/main content for {url}"); return None
         lines = [line.strip() for line in target_element.get_text(separator='\n', strip=True).splitlines() if line.strip()]
         text = "\n".join(lines)
         MIN_TEXT_LENGTH = 50
-        if not text or len(text) < MIN_TEXT_LENGTH:
-             logger.warning(f"[Web Scraper - Requests/BS4] Extracted text is very short (<{MIN_TEXT_LENGTH} chars) for {url} (Length: {len(text)})")
-        logger.info(f"[Web Scraper - Requests/BS4] Successfully scraped content for {url} (final length: {len(text)})")
+        if not text or len(text) < MIN_TEXT_LENGTH: logger.warning(f"[Web Scraper - Requests/BS4] Text too short (<{MIN_TEXT_LENGTH} chars) for {url} (Len: {len(text)})")
+        logger.info(f"[Web Scraper - Requests/BS4] Success scraping {url} (Len: {len(text)})")
         return text
-    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - Requests/BS4] Timeout error scraping {url}"); return None
-    except requests.exceptions.TooManyRedirects: logger.error(f"[Web Scraper - Requests/BS4] Too many redirects for {url}"); return None
-    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - Requests/BS4] Request error scraping {url}: {e}"); return None
-    except Exception as e: logger.error(f"[Web Scraper - Requests/BS4] Error scraping or parsing {url}: {e}", exc_info=True); return None
+    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - Requests/BS4] Timeout: {url}"); return None
+    except requests.exceptions.TooManyRedirects: logger.error(f"[Web Scraper - Requests/BS4] Redirects: {url}"); return None
+    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - Requests/BS4] Request error {url}: {e}"); return None
+    except Exception as e: logger.error(f"[Web Scraper - Requests/BS4] Parsing error {url}: {e}", exc_info=True); return None
 
 # Website Content via URLToText API
 async def get_website_content_via_urltotext_api(url: str, api_key: str):
     """Fetches website content using the URLToText API."""
-    if not url: logger.error("[Web Scraper - URLToText API] called with no URL"); return None
-    if not api_key: logger.error("[Web Scraper - URLToText API] API key is missing."); return None
-    logger.info(f"[Web Scraper - URLToText API] Attempting fetch for: {url}")
+    if not url: logger.error("[Web Scraper - URLToText API] no URL"); return None
+    if not api_key: logger.error("[Web Scraper - URLToText API] API key missing."); return None
+    logger.info(f"[Web Scraper - URLToText API] Attempting fetch: {url}")
     api_endpoint = "https://urltotext.com/api/v1/urltotext/"
     payload = json.dumps({"url": url, "output_format": "text", "extract_main_content": True, "render_javascript": True, "residential_proxy": False})
     headers = {"Authorization": f"Token {api_key}", "Content-Type": "application/json"}
     try:
-        logger.debug(f"[Web Scraper - URLToText API] Sending POST request for {url}")
         response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=45)
-        logger.debug(f"[Web Scraper - URLToText API] Received status code {response.status_code} for {url}")
+        logger.debug(f"[Web Scraper - URLToText API] Status {response.status_code} for {url}")
         if response.status_code == 200:
             try:
                 data = response.json()
-                content = data.get("data", {}).get("content")
-                credits = data.get("credits_used", "N/A")
-                warning = data.get("data", {}).get("warning")
+                content = data.get("data", {}).get("content"); credits = data.get("credits_used", "N/A"); warning = data.get("data", {}).get("warning")
                 if warning: logger.warning(f"[Web Scraper - URLToText API] Warning for {url}: {warning}")
-                if content:
-                    logger.info(f"[Web Scraper - URLToText API] Successfully fetched content via API for {url}. Length: {len(content)}. Credits: {credits}")
-                    return content.strip()
-                else:
-                    logger.warning(f"[Web Scraper - URLToText API] API success (200) but content empty for {url}. Response: {data}")
-                    return None
-            except json.JSONDecodeError: logger.error(f"[Web Scraper - URLToText API] Failed JSON decode for {url}. Status: {response.status_code}. Resp: {response.text[:500]}..."); return None
-            except Exception as e: logger.error(f"[Web Scraper - URLToText API] Error processing successful API response for {url}: {e}", exc_info=True); return None
-        elif response.status_code == 400: logger.error(f"[Web Scraper - URLToText API] Bad Request (400) for {url}. Resp: {response.text[:200]}...")
-        elif response.status_code == 401: logger.error(f"[Web Scraper - URLToText API] Unauthorized (401) for {url}. Check Key. Resp: {response.text[:200]}...")
-        elif response.status_code == 402: logger.error(f"[Web Scraper - URLToText API] Payment Required (402) for {url}. Check credits. Resp: {response.text[:200]}...")
-        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL (422) for {url}. Resp: {response.text[:200]}...")
-        elif response.status_code >= 500: logger.error(f"[Web Scraper - URLToText API] Server Error ({response.status_code}) from API for {url}. Resp: {response.text[:200]}...")
-        else: logger.error(f"[Web Scraper - URLToText API] Unexpected status {response.status_code} from API for {url}. Resp: {response.text[:200]}...")
+                if content: logger.info(f"[Web Scraper - URLToText API] Success via API. Length: {len(content)}. Credits: {credits}"); return content.strip()
+                else: logger.warning(f"[Web Scraper - URLToText API] API success (200) but content empty. Resp: {data}"); return None
+            except json.JSONDecodeError: logger.error(f"[Web Scraper - URLToText API] Failed JSON decode. Status: {response.status_code}. Resp: {response.text[:500]}..."); return None
+            except Exception as e: logger.error(f"[Web Scraper - URLToText API] Error processing API response: {e}", exc_info=True); return None
+        elif response.status_code == 400: logger.error(f"[Web Scraper - URLToText API] Bad Request (400). Resp: {response.text[:200]}...")
+        elif response.status_code == 401: logger.error(f"[Web Scraper - URLToText API] Unauthorized (401). Check Key. Resp: {response.text[:200]}...")
+        elif response.status_code == 402: logger.error(f"[Web Scraper - URLToText API] Payment Required (402). Check credits. Resp: {response.text[:200]}...")
+        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL (422). Resp: {response.text[:200]}...")
+        elif response.status_code >= 500: logger.error(f"[Web Scraper - URLToText API] Server Error ({response.status_code}). Resp: {response.text[:200]}...")
+        else: logger.error(f"[Web Scraper - URLToText API] Unexpected status {response.status_code}. Resp: {response.text[:200]}...")
         return None
-    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - URLToText API] Timeout error connecting for {url}"); return None
-    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - URLToText API] Request error connecting for {url}: {e}"); return None
-    except Exception as e: logger.error(f"[Web Scraper - URLToText API] Unexpected error during API call for {url}: {e}", exc_info=True); return None
+    except requests.exceptions.Timeout: logger.error(f"[Web Scraper - URLToText API] Timeout: {url}"); return None
+    except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - URLToText API] Request error: {e}"); return None
+    except Exception as e: logger.error(f"[Web Scraper - URLToText API] Unexpected error: {e}", exc_info=True); return None
 
 # DeepSeek Summary Function
 async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
@@ -382,23 +337,21 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
     logger.info(f"Generating '{summary_type}' summary. Input length: {len(text)}")
     if not api_key: logger.error("OpenRouter API key missing."); return "Error: AI config key missing."
     if not text: logger.warning("generate_summary called with empty text."); return "Error: No content to summarize."
-    openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"
-    model_name = "deepseek/deepseek-chat:free"
+    openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"; model_name = "deepseek/deepseek-chat:free"
     if summary_type == "paragraph": prompt = "Please provide a concise, well-written paragraph summarizing the key information and main points of the following text. Focus on capturing the essence of the content accurately."
     elif summary_type == "points": prompt = "Please summarize the following text into clear, distinct bullet points. Each point should highlight a key piece of information, finding, or main topic discussed. Aim for clarity and conciseness."
     else: logger.error(f"Invalid summary_type '{summary_type}'."); return f"Error: Invalid summary type ('{summary_type}')."
     MAX_INPUT_LENGTH = 500000
     if len(text) > MAX_INPUT_LENGTH: logger.warning(f"Input text ({len(text)}) > limit ({MAX_INPUT_LENGTH}). Truncating."); text = text[:MAX_INPUT_LENGTH] + "... (Truncated)"
     full_prompt = f"{prompt}\n\n--- Start of Text ---\n\n{text}\n\n--- End of Text ---"
-    # Try getting space host for referer header
-    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME") # Default if env var not set
+    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME")
     referer_url = f"https://{space_host}" if not space_host.startswith("http") else space_host
     headers = {"Authorization": f"Bearer {api_key}","Content-Type": "application/json","HTTP-Referer": referer_url,"X-Title": "Telegram URL Summarizer Bot"}
     payload = json.dumps({"model": model_name, "messages": [{"role": "user", "content": full_prompt}]})
     try:
         logger.debug(f"Sending request to OpenRouter (Model: {model_name})...")
         response = await asyncio.to_thread(requests.post, openrouter_api_endpoint, headers=headers, data=payload, timeout=90)
-        logger.debug(f"Received status code {response.status_code} from OpenRouter.")
+        logger.debug(f"Received status {response.status_code} from OpenRouter.")
         if response.status_code == 200:
             try:
                 data = response.json()
@@ -413,7 +366,7 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
                 else: logger.error(f"Unexpected OpenRouter choices structure. Resp: {data}"); return "Sorry, could not parse AI response (choices)."
             except json.JSONDecodeError: logger.error(f"Failed JSON decode from OpenRouter. Status: {response.status_code}. Resp: {response.text[:500]}..."); return "Sorry, failed to understand AI response format."
             except Exception as e: logger.error(f"Error processing OpenRouter success resp: {e}", exc_info=True); return "Sorry, error processing AI response."
-        elif response.status_code == 401: logger.error("OpenRouter API key invalid (401)."); return "Error: AI model config key invalid."
+        elif response.status_code == 401: logger.error("OpenRouter key invalid (401)."); return "Error: AI model config key invalid."
         elif response.status_code == 402: logger.error("OpenRouter Payment Required (402)."); return "Sorry, issue with AI service limits/payment."
         elif response.status_code == 429: logger.warning("OpenRouter Rate Limit (429)."); return "Sorry, AI model busy. Try again."
         elif response.status_code >= 500: logger.error(f"OpenRouter Internal Error ({response.status_code}). Resp: {response.text[:500]}..."); return "Sorry, AI model service error. Try again later."
@@ -429,43 +382,37 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
 # --- Telegram Bot Handlers ---
 
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    """Handles the /start command."""
-    user = update.effective_user
+    user = update.effective_user;
     if not user: return
-    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) triggered /start.")
+    logger.info(f"User {user.id} ({user.username or 'NoUsername'}) /start.")
     mention = user.mention_html() if user.username else user.first_name
-    await update.message.reply_html(f"👋 Hello {mention}! Send a YouTube or website URL to summarize.")
+    await update.message.reply_html(f"👋 Hello {mention}! Send a URL to summarize.")
 
 async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    """Handles the /help command."""
-    user = update.effective_user
-    logger.info(f"User {user.id if user else 'Unknown'} triggered /help.")
-    help_text = ( "**How I Work:**\n\n" # ... (keep your detailed help text) ...
-        "1. Send URL.\n2. Choose format (Paragraph/Points).\n3. Get summary!\n\n"
-        "**Troubleshooting:**\n- YT transcripts might fail.\n- Complex websites hard to scrape.\n- AI errors possible.\n\nSend link to start!" )
+    user = update.effective_user; logger.info(f"User {user.id if user else '?'} /help.")
+    help_text = ("**How:**\n1. Send URL.\n2. Choose Paragraph/Points.\n3. Get summary!\n\n"
+                 "**Notes:**\n- YT transcripts can fail.\n- Complex sites hard to scrape.\n- AI errors possible.")
     await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
 
 async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    """Handles messages containing potential URLs."""
     if not update.message or not update.message.text: return
     message_text = update.message.text.strip(); user = update.effective_user;
     if not user: return
     url_pattern = r'https?://[^\s/$.?#].[^\s]*'; match = re.search(url_pattern, message_text)
     if match:
-        url = match.group(0); logger.info(f"User {user.id} sent potential URL: {url}")
+        url = match.group(0); logger.info(f"User {user.id} sent URL: {url}")
         context.user_data['url_to_summarize'] = url; logger.debug(f"Stored URL '{url}' for user {user.id}")
-        keyboard = [[ InlineKeyboardButton("Paragraph", callback_data="paragraph"), InlineKeyboardButton("Points", callback_data="points")]]
+        keyboard = [[InlineKeyboardButton("Paragraph", callback_data="paragraph"), InlineKeyboardButton("Points", callback_data="points")]]
         reply_markup = InlineKeyboardMarkup(keyboard)
-        await update.message.reply_text(f"Link detected:\n{url}\n\nChoose summary type:", reply_markup=reply_markup, link_preview_options={'is_disabled': True})
-    else: logger.debug(f"Ignoring non-URL message from {user.id}: {message_text[:100]}")
+        await update.message.reply_text(f"Link:\n{url}\n\nChoose summary type:", reply_markup=reply_markup, link_preview_options={'is_disabled': True})
+    else: logger.debug(f"Ignoring non-URL from {user.id}: {message_text[:100]}")
 
 async def handle_summary_type_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    """Handles button presses for choosing the summary type."""
     query = update.callback_query; user = query.from_user
-    try: await query.answer(); logger.debug(f"Answered callback query {query.id}")
-    except Exception as e: logger.error(f"Failed to answer callback query {query.id}: {e}")
+    try: await query.answer(); logger.debug(f"Answered query {query.id}")
+    except Exception as e: logger.error(f"Failed answer query {query.id}: {e}")
     summary_type = query.data; url = context.user_data.get('url_to_summarize')
-    logger.info(f"User {user.id} chose '{summary_type}'. URL in context: '{url}'.")
+    logger.info(f"User {user.id} chose '{summary_type}'. URL: '{url}'.")
     if not url:
         logger.warning(f"User {user.id} pressed button, NO URL in context.");
         try: await query.edit_message_text(text="Context lost. Send link again.")
@@ -474,10 +421,10 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
     context.user_data.pop('url_to_summarize', None); logger.debug(f"Cleared URL {url} for user {user.id}")
     current_openrouter_key = os.environ.get('OPENROUTER_API_KEY'); current_urltotext_key = os.environ.get('URLTOTEXT_API_KEY')
     current_supadata_key = os.environ.get('SUPADATA_API_KEY'); current_apify_token = os.environ.get('APIFY_API_TOKEN')
-    logger.debug(f"Keys read: OR={'Y' if current_openrouter_key else 'N'}, UTT={'Y' if current_urltotext_key else 'N'}, SD={'Y' if current_supadata_key else 'N'}, AP={'Y' if current_apify_token else 'N'}")
+    logger.debug(f"Keys: OR={'Y' if current_openrouter_key else 'N'}, UTT={'Y' if current_urltotext_key else 'N'}, SD={'Y' if current_supadata_key else 'N'}, AP={'Y' if current_apify_token else 'N'}")
     if not current_openrouter_key:
         logger.error("OpenRouter key missing.");
-        try: await query.edit_message_text(text="⚠️ AI service config error (key missing). Contact admin.")
+        try: await query.edit_message_text(text="⚠️ AI service config error (key missing).")
         except Exception as edit_err: logger.error(f"Failed edit on missing OR key: {edit_err}")
         return
     processing_message_text = f"Working on '{summary_type}' summary for:\n{url}\n..."; message_to_delete_later_id = None
@@ -514,9 +461,10 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
             else: logger.info("Summary generated OK. Sending."); await context.bot.send_message(chat_id=user.id, text=summary, parse_mode=ParseMode.MARKDOWN, link_preview_options={'is_disabled': True}); success = True; user_feedback_message = None
         elif not user_feedback_message: user_feedback_message = "Sorry, couldn't retrieve content from link."
         if user_feedback_message and not success: logger.warning(f"Sending failure feedback: {user_feedback_message}"); await context.bot.send_message(chat_id=user.id, text=user_feedback_message)
-    except Exception as e: logger.error(f"Unexpected error in callback processing: {e}", exc_info=True);
-    try: await context.bot.send_message(chat_id=user.id, text="Oops! Internal error processing request.")
-    except Exception as final_err: logger.error(f"Failed sending final error message: {final_err}")
+    except Exception as e:
+        logger.error(f"Unexpected error in callback processing: {e}", exc_info=True);
+        try: await context.bot.send_message(chat_id=user.id, text="Oops! Internal error processing request.")
+        except Exception as final_err: logger.error(f"Failed sending final error message: {final_err}")
     finally:
         logger.debug("Cleaning up status message...");
         try:
@@ -564,14 +512,20 @@ async def lifespan(app: Starlette): # app argument is the Starlette instance
         WEBHOOK_URL_BASE = os.environ.get("SPACE_HOST")
         if WEBHOOK_URL_BASE:
             if not WEBHOOK_URL_BASE.startswith("https://"): WEBHOOK_URL_BASE = f"https://{WEBHOOK_URL_BASE}"
-            webhook_path = "/webhook" # Matches Flask route
+            webhook_path = "/webhook"
             full_webhook_url = f"{WEBHOOK_URL_BASE.rstrip('/')}{webhook_path}"
             logger.info(f"Attempting to set webhook to: {full_webhook_url}")
             try:
+                # Add a small delay before setting webhook, especially with multiple workers
+                # This might help avoid the initial rate limit error, although one worker succeeding is enough.
+                await asyncio.sleep(1.5) # Wait 1.5 seconds
                 await ptb_app.bot.set_webhook(url=full_webhook_url, allowed_updates=Update.ALL_TYPES)
                 webhook_info = await ptb_app.bot.get_webhook_info()
                 logger.info(f"Webhook set successfully! Info: {webhook_info}")
-            except Exception as e: logger.error(f"Failed to set webhook: {e}", exc_info=True)
+            except RetryAfter as e:
+                 logger.warning(f"Webhook set failed due to rate limit (RetryAfter: {e.retry_after}s). Another worker likely succeeded.")
+            except Exception as e:
+                 logger.error(f"Failed to set webhook: {e}", exc_info=True)
         else: logger.warning("SPACE_HOST env variable not found. Skipping webhook setup.")
 
         logger.info("ASGI Lifespan: Startup complete. Application ready.")
@@ -579,12 +533,12 @@ async def lifespan(app: Starlette): # app argument is the Starlette instance
 
     except Exception as startup_err:
         logger.critical(f"CRITICAL ERROR during ASGI startup: {startup_err}", exc_info=True)
-        # Optionally re-raise or handle to prevent server from potentially running in bad state
         raise
     finally:
         # --- Shutdown ---
         logger.info("ASGI Lifespan: Shutdown commencing...")
-        if ptb_app and ptb_app.is_running:
+        # Use the correct attribute to check if running before stopping/shutting down
+        if ptb_app and ptb_app._running: # <--- Use _running here too
             try:
                 logger.info("Stopping PTB App...")
                 await ptb_app.stop()
@@ -610,15 +564,26 @@ def index():
     """Basic health check endpoint."""
     logger.debug("Health check '/' accessed.")
     bot_status = "UNKNOWN"
-    if ptb_app: bot_status = "Running" if ptb_app.is_running else "Initialized/Stopped/Starting/Error"
-    else: bot_status = "Not Initialized"
+    if ptb_app:
+        # --- CORRECTED CHECK ---
+        bot_status = "Running" if ptb_app._running else "Initialized/Stopped/Starting/Error"
+        # --- END CORRECTION ---
+    else:
+        bot_status = "Not Initialized"
     return f"Telegram Bot Webhook Listener ({bot_status}) running via Starlette."
 
 @flask_core_app.route('/webhook', methods=['POST'])
 async def webhook() -> Response:
     """Webhook endpoint for Telegram updates."""
-    if not ptb_app or not ptb_app.is_running:
-        status = "Not Initialized" if not ptb_app else "Not Running"
+    if not ptb_app: # Check if instance exists first
+        logger.error("Webhook triggered, but PTB Application instance (ptb_app) is None.")
+        return Response('Bot service not configured.', status=503)
+
+    # --- CORRECTED CHECK ---
+    # Use the internal _running attribute as suggested by the AttributeError
+    if not ptb_app._running:
+    # --- END CORRECTION ---
+        status = "Not Running" # If instance exists but not running
         logger.error(f"Webhook triggered, but PTB Application is {status}.")
         return Response('Bot service not ready.', status=503)