Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Revised: Increased Pool/Timeouts + Robust Callback Handling)
+# main.py (Revised: Corrected HTTPXRequest init for PTB v20 + Robust Callback Handling)
 import os
 import re
 import logging
@@ -28,7 +28,7 @@ from telegram.error import NetworkError, RetryAfter, TimedOut # Import TimedOut
 from telegram.request import HTTPXRequest # Import the request class
 
 # --- Other Libraries ---
-import httpx # <<<--- ADDED IMPORT for httpx.Limits
+import httpx # Keep import, might be useful elsewhere or if upgrading PTB later
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 from bs4 import BeautifulSoup
@@ -62,7 +62,6 @@ ptb_app: Application | None = None
 # --- Environment Variable Loading ---
 logger.info("Attempting to load secrets...")
 def get_secret(secret_name):
-    # logger.debug(f"Attempting to read secret: {secret_name}") # Optional: Less verbose startup
     value = os.environ.get(secret_name)
     if value: logger.info(f"Secret '{secret_name}': Found (Value length: {len(value)})")
     else: logger.warning(f"Secret '{secret_name}': Not Found")
@@ -80,7 +79,7 @@ logger.info("Secret loading attempt finished.")
 # (Keep ALL your functions: is_youtube_url, extract_youtube_id,
 #  get_transcript_via_supadata, get_transcript_via_apify,
 #  get_youtube_transcript, get_website_content_via_requests,
-#  get_website_content_via_urltotext_api, generate_summary)
+#  get_website_content_via_urltotext_api, generate_summary - unchanged from previous version)
 
 # Helper Functions
 def is_youtube_url(url):
@@ -112,7 +111,6 @@ async def get_transcript_via_supadata(video_id: str, api_key: str):
     params = {"videoId": video_id, "format": "text"}
     headers = {"X-API-Key": api_key}
     try:
-        # Consider removing verify=False if possible, or manage certificates properly
         logger.warning("[Supadata] Making request with verify=False (Attempting to bypass SSL verification - Potential Security Risk)")
         response = await asyncio.to_thread(requests.get, api_endpoint, headers=headers, params=params, timeout=30, verify=False)
         logger.debug(f"[Supadata] Received status code {response.status_code} for {video_id}")
@@ -284,23 +282,21 @@ async def get_website_content_via_requests(url):
     if not url: logger.error("[Web Scraper - Requests/BS4] get_website_content_via_requests called with no URL"); return None
     logger.info(f"[Web Scraper - Requests/BS4] Attempting fetch: {url}")
     try:
-        # Standard headers, avoid overly aggressive scraping patterns
         headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36', # Updated UA
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.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', # Do Not Track header
+            'DNT': '1',
             'Upgrade-Insecure-Requests': '1'
         }
         response = await asyncio.to_thread(requests.get, url, headers=headers, timeout=25, allow_redirects=True)
-        response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
+        response.raise_for_status()
         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}. Attempting plain text extraction.")
-            # Allow plain text only if explicitly text/plain
             if 'text/plain' in content_type and response.text:
                  logger.info(f"[Web Scraper - Requests/BS4] Extracted plain text content. Length: {len(response.text.strip())}")
                  return response.text.strip()
@@ -308,39 +304,25 @@ async def get_website_content_via_requests(url):
             return None
 
         soup = BeautifulSoup(response.text, 'html.parser')
-
-        # Remove common non-content tags more aggressively
         tags_to_remove = ["script", "style", "header", "footer", "nav", "aside", "form", "button", "input", "textarea", "select", "option", "label", "iframe", "img", "svg", "link", "meta", "noscript", "figure", "figcaption", "video", "audio", "picture", "source"]
-        # Also remove elements often used for ads or menus by class/id
         selectors_to_remove = ['.ad', '#ad', '.ads', '#ads', '.advertisement', '#advertisement', '.banner', '#banner', '.menu', '#menu', '.navigation', '#navigation', '.sidebar', '#sidebar', '.social', '#social', '.share', '#share', '.related', '#related', '.comments', '#comments', '.cookie-consent', '#cookie-consent']
-
         for tag in soup(tags_to_remove): tag.decompose()
         for selector in selectors_to_remove:
             for element in soup.select(selector): element.decompose()
 
-        # Try to find semantic main content areas first
-        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')
-
+        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 a suitable target element (main, article, body) for {url}");
             return None
 
-        # Extract text, attempting to preserve paragraphs better
         lines = [line.strip() for line in target_element.get_text(separator='\n', strip=True).splitlines() if line.strip()]
-        text = "\n\n".join(lines) # Join lines with double newline for paragraph separation
+        text = "\n\n".join(lines)
 
-        MIN_TEXT_LENGTH = 100 # Increased minimum length
+        MIN_TEXT_LENGTH = 100
         if not text or len(text) < MIN_TEXT_LENGTH:
              logger.warning(f"[Web Scraper - Requests/BS4] Extracted text is too short (<{MIN_TEXT_LENGTH} chars) after cleaning for {url}. Length: {len(text)}. Content might be JS-rendered or blocked.")
-             # Optional: Log the short text for debugging: logger.debug(f"Short text: {text[:500]}")
-             return None # Treat very short text as failure
+             return None
 
         logger.info(f"[Web Scraper - Requests/BS4] Successfully scraped and cleaned content from {url}. Final Length: {len(text)}")
         return text
@@ -358,18 +340,17 @@ async def get_website_content_via_urltotext_api(url: str, api_key: str):
     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 via API: {url}")
     api_endpoint = "https://urltotext.com/api/v1/urltotext/"
-    # Ensure payload includes options beneficial for scraping modern sites
     payload = json.dumps({
         "url": url,
         "output_format": "text",
-        "extract_main_content": True, # Try to get just the core article/content
-        "render_javascript": True,   # Crucial for JS-heavy sites
-        "residential_proxy": False,  # Set to True if facing blocks, requires appropriate plan
-        "timeout_render": 20000,     # Increase JS render timeout (in ms)
+        "extract_main_content": True,
+        "render_javascript": True,
+        "residential_proxy": False,
+        "timeout_render": 20000,
     })
     headers = {"Authorization": f"Token {api_key}", "Content-Type": "application/json"}
     try:
-        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=60) # Increased overall timeout
+        response = await asyncio.to_thread(requests.post, api_endpoint, headers=headers, data=payload, timeout=60)
         logger.debug(f"[Web Scraper - URLToText API] Received status code {response.status_code} for {url}")
         if response.status_code == 200:
             try:
@@ -378,10 +359,10 @@ async def get_website_content_via_urltotext_api(url: str, api_key: str):
                 content = content_data.get("content")
                 credits = data.get("credits_used", "N/A")
                 warning = content_data.get("warning")
-                error_msg = content_data.get("error") # Check for specific error in response data
+                error_msg = content_data.get("error")
 
                 if warning: logger.warning(f"[Web Scraper - URLToText API] API Warning for {url}: {warning}")
-                if error_msg: logger.error(f"[Web Scraper - URLToText API] API Error reported for {url}: {error_msg}"); return None # Treat API error as failure
+                if error_msg: logger.error(f"[Web Scraper - URLToText API] API Error reported for {url}: {error_msg}"); return None
 
                 if content and isinstance(content, str):
                     logger.info(f"[Web Scraper - URLToText API] Successfully fetched content via API. Length: {len(content.strip())}. Credits Used: {credits}");
@@ -394,11 +375,11 @@ async def get_website_content_via_urltotext_api(url: str, api_key: str):
         elif response.status_code == 400: logger.error(f"[Web Scraper - URLToText API] Bad Request (400) to API. Check payload/URL. Response: {response.text[:200]}...")
         elif response.status_code == 401: logger.error(f"[Web Scraper - URLToText API] Unauthorized (401). Check API Key. Response: {response.text[:200]}...")
         elif response.status_code == 402: logger.error(f"[Web Scraper - URLToText API] Payment Required (402). Check API credits/plan. Response: {response.text[:200]}...")
-        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL / Fetch Error (422) reported by API for {url}. Response: {response.text[:200]}...") # Might mean the site blocked the API
+        elif response.status_code == 422: logger.warning(f"[Web Scraper - URLToText API] Unprocessable URL / Fetch Error (422) reported by API for {url}. Response: {response.text[:200]}...")
         elif response.status_code == 429: logger.warning(f"[Web Scraper - URLToText API] Rate Limit Hit (429). Response: {response.text[:200]}...")
         elif response.status_code >= 500: logger.error(f"[Web Scraper - URLToText API] API Server Error ({response.status_code}). Response: {response.text[:200]}...")
         else: logger.error(f"[Web Scraper - URLToText API] Unexpected status code {response.status_code} from API. Response: {response.text[:200]}...")
-        return None # Return None for all non-200 responses after logging
+        return None
     except requests.exceptions.Timeout: logger.error(f"[Web Scraper - URLToText API] Timeout connecting to API for {url}"); return None
     except requests.exceptions.RequestException as e: logger.error(f"[Web Scraper - URLToText API] Request error connecting to API: {e}"); return None
     except Exception as e: logger.error(f"[Web Scraper - URLToText API] Unexpected error during API call: {e}", exc_info=True); return None
@@ -411,11 +392,8 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
     if not text or not text.strip(): logger.warning("generate_summary called with empty or whitespace-only text."); return "Error: No content was provided to summarize."
 
     openrouter_api_endpoint = "https://openrouter.ai/api/v1/chat/completions"
-    # Consider using a non-free model if rate limits are hit or quality needed
     model_name = "deepseek/deepseek-chat:free"
-    # model_name = "openai/gpt-3.5-turbo" # Example alternative
 
-    # --- UPDATED PROMPTS ---
     if summary_type == "paragraph":
         system_message = (
             "You are an expert summarization AI. Your goal is to provide a concise, easy-to-understand summary of the provided text. "
@@ -449,12 +427,8 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
     else:
         logger.error(f"Invalid summary_type '{summary_type}' requested.")
         return f"Error: Invalid summary type ('{summary_type}') requested. Please choose 'paragraph' or 'points'."
-    # --- END UPDATED PROMPTS ---
 
-    # Practical limit for API context window / cost control
-    # Deepseek context might be larger, but set a reasonable app limit
-    MAX_INPUT_TOKENS_ESTIMATE = 28000 # Rough estimate for deepseek-chat's context limit (aim lower than max)
-    # Simple character length heuristic (adjust based on typical content)
+    MAX_INPUT_TOKENS_ESTIMATE = 28000
     AVG_CHARS_PER_TOKEN = 4
     MAX_INPUT_LENGTH = MAX_INPUT_TOKENS_ESTIMATE * AVG_CHARS_PER_TOKEN
 
@@ -463,33 +437,29 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
         truncation_marker = "\n\n[... Text truncated due to length ...]"
         text = text[:MAX_INPUT_LENGTH - len(truncation_marker)] + truncation_marker
 
-    # Construct the messages payload for the API
     messages = [
         {"role": "system", "content": system_message},
         {"role": "user", "content": f"{user_prompt_instruction}\n\n--- TEXT TO SUMMARIZE ---\n\n{text}\n\n--- END OF TEXT ---"}
     ]
 
-    # Referer and Title for OpenRouter identification
-    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME") # Replace default if needed
+    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME")
     referer_url = f"https://{space_host}" if space_host and not space_host.startswith("http") else space_host or "https://huggingface.co"
     headers = {
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json",
         "HTTP-Referer": referer_url,
-        "X-Title": "Telegram URL Summarizer Bot" # Or your bot's name
+        "X-Title": "Telegram URL Summarizer Bot"
     }
     payload = json.dumps({"model": model_name, "messages": messages})
 
     try:
         logger.debug(f"Sending request to OpenRouter (Model: {model_name}). Prompt length approx: {len(text)} chars.")
-        # Increased timeout for potentially long AI generation
         response = await asyncio.to_thread(requests.post, openrouter_api_endpoint, headers=headers, data=payload, timeout=120)
         logger.debug(f"Received status {response.status_code} from OpenRouter.")
 
         if response.status_code == 200:
             try:
                 data = response.json()
-                # Check for response structure variations
                 choice = data.get("choices", [{}])[0]
                 message = choice.get("message", {})
                 summary = message.get("content")
@@ -498,8 +468,7 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
                 if summary and isinstance(summary, str) and summary.strip():
                     summary = summary.strip()
                     logger.info(f"Successfully generated summary. Finish Reason: {finish_reason}. Length: {len(summary)}")
-                    # Optional: Add post-processing checks (e.g., length for paragraph)
-                    if summary_type == "paragraph" and len(summary.split()) > 95: # Allow slight overrun from 85 words
+                    if summary_type == "paragraph" and len(summary.split()) > 95:
                          logger.warning(f"Generated paragraph summary slightly longer than target word count ({len(summary.split())} words).")
                     return summary
                 else:
@@ -513,16 +482,14 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
                 logger.error(f"Unexpected error processing OpenRouter success response: {e}", exc_info=True)
                 return "Sorry, an unexpected error occurred while processing the AI response."
 
-        # Handle specific HTTP error codes from OpenRouter
         elif response.status_code == 401: logger.error("OpenRouter API key is invalid (Unauthorized - 401)."); return "Error: AI service authentication failed. Please check the configuration."
         elif response.status_code == 402: logger.error("OpenRouter Payment Required (402). Check credits/limits."); return "Sorry, there's an issue with the AI service account limits or payment."
         elif response.status_code == 429: logger.warning("OpenRouter Rate Limit Hit (429)."); return "Sorry, the AI model is currently busy due to high demand. Please try again in a moment."
         elif response.status_code == 400: logger.error(f"OpenRouter Bad Request (400). Likely prompt issue. Response: {response.text[:500]}..."); return "Sorry, the request to the AI service was invalid (possibly due to the content or prompt)."
         elif response.status_code >= 500: logger.error(f"OpenRouter Server Error ({response.status_code}). Response: {response.text[:500]}..."); return "Sorry, the AI service is experiencing internal issues. Please try again later."
         else:
-             # Handle other unexpected errors
              logger.error(f"Unexpected HTTP status {response.status_code} from OpenRouter. Response: {response.text[:500]}...")
-             try: # Try to extract an error message from the response body
+             try:
                  error_data = response.json()
                  error_msg = error_data.get("error", {}).get("message", response.text[:100])
                  return f"Sorry, the AI service returned an error ({response.status_code}): {error_msg}"
@@ -539,9 +506,8 @@ async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Handles the /start command."""
     user = update.effective_user
-    if not user: return # Should not happen with a command
+    if not user: return
     logger.info(f"User {user.id} ({user.username or 'NoUsername'}) initiated /start.")
-    # Use mention_html for linking username if available, otherwise just first name
     mention = user.mention_html() if user.username else user.first_name
     start_message = (
         f"👋 Hello {mention}!\n\n"
@@ -568,7 +534,6 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
         "- **Length:** Very long articles or videos might be truncated before summarization to fit within processing limits.\n\n"
         "Just send a link to get started!"
     )
-    # Use MarkdownV2 for better formatting control if needed, but MARKDOWN is simpler
     await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
 
 async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
@@ -576,18 +541,14 @@ async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYP
     if not update.message or not update.message.text: return
     message_text = update.message.text.strip()
     user = update.effective_user
-    if not user: return # Should not happen with a message
+    if not user: return
 
-    # More robust URL regex (handles various protocols, domains, paths, queries)
-    # Still simple, not aiming for perfect RFC 3986 validation
     url_pattern = r'https?://(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}(?:/[^\s]*)?'
     match = re.search(url_pattern, message_text)
 
     if match:
         url = match.group(0)
         logger.info(f"User {user.id} sent potential URL: {url}")
-
-        # Store URL in user_data, associated with the user ID
         context.user_data['url_to_summarize'] = url
         logger.debug(f"Stored URL '{url}' in user_data for user {user.id}")
 
@@ -598,18 +559,13 @@ async def handle_potential_url(update: Update, context: ContextTypes.DEFAULT_TYP
             ]
         ]
         reply_markup = InlineKeyboardMarkup(keyboard)
-
-        # Send message asking for summary type
         await update.message.reply_text(
             f"✅ Link received:\n`{url}`\n\nChoose your desired summary format:",
             reply_markup=reply_markup,
             parse_mode=ParseMode.MARKDOWN,
-            link_preview_options={'is_disabled': True} # Disable link preview for this message
+            link_preview_options={'is_disabled': True}
         )
     else:
-        # If it doesn't look like a URL, maybe provide guidance?
-        # logger.debug(f"Ignoring non-URL message from {user.id}: {message_text[:100]}")
-        # Optional: Reply if it's not a command and not a URL
         if not message_text.startswith('/'):
              await update.message.reply_text("Please send me a valid URL (starting with http:// or https://) to summarize.")
 
@@ -619,53 +575,42 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
     query = update.callback_query
     if not query or not query.from_user:
         logger.warning("Callback query or user missing in update.")
-        return # Can't proceed without query/user
+        return
     user = query.from_user
 
-    # --- Answer Callback Query Immediately ---
     try:
-        await query.answer() # Acknowledge the button press
+        await query.answer()
         logger.debug(f"Answered callback query {query.id} for user {user.id}")
     except TimedOut:
-        # Log timeout but proceed; the button loading indicator might just hang for the user
         logger.warning(f"Timeout answering callback query {query.id} for user {user.id}. Processing continues.")
     except Exception as e:
-        # Log other errors but proceed cautiously. The button might remain "loading".
         logger.error(f"Error answering callback query {query.id} for user {user.id}: {e!r}", exc_info=True)
 
-    summary_type = query.data # 'paragraph' or 'points'
-    # Retrieve URL stored earlier for this user
+    summary_type = query.data
     url = context.user_data.get('url_to_summarize')
     logger.info(f"User {user.id} chose summary type '{summary_type}'. Checking for stored URL.")
 
     if not url:
         logger.warning(f"User {user.id} pressed button '{summary_type}', but NO URL found in user_data context.")
         try:
-            # Inform user context was lost (e.g., bot restarted, long delay)
             await query.edit_message_text(text="⚠️ Oops! I lost the context for that link. Please send the link again.")
         except TimedOut:
              logger.error(f"Timeout trying to edit message to inform user {user.id} about lost context.")
         except Exception as edit_err:
-            # Log error if editing fails (message might already be gone, or other Telegram issue)
             logger.error(f"Failed to edit message for lost context for user {user.id}: {edit_err}")
-        return # Stop processing if URL is missing
+        return
 
-    # --- URL Found - Proceed with Processing ---
     logger.info(f"Processing URL '{url}' for user {user.id} with type '{summary_type}'.")
-    # Clear the URL from context now that we're processing it
     context.user_data.pop('url_to_summarize', None)
     logger.debug(f"Cleared URL from user_data for user {user.id}")
 
-    # Fetch current API keys (allows for potential runtime changes, though unlikely here)
     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')
-    # Simple check log
     keys_present = f"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"API Key check for user {user.id} request: {keys_present}")
 
-    # Critical dependency check: AI key
     if not current_openrouter_key:
         logger.error(f"CRITICAL: OpenRouter API key is missing. Cannot generate summary for user {user.id}.")
         try:
@@ -676,47 +621,39 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
             logger.error(f"Failed to edit message for missing AI key for user {user.id}: {edit_err}")
         return
 
-    # --- Inform User Processing Has Started ---
     processing_message_text = f"⏳ Working on your '{summary_type}' summary for the link...\n_(This might take up to a minute depending on the content)_"
-    message_to_edit = query.message # The message with the buttons
-    status_message_sent = None      # Will hold msg ID if we send a new status message
+    message_to_edit = query.message
+    status_message_sent = None
 
     try:
         if message_to_edit:
             await query.edit_message_text(text=processing_message_text)
             logger.debug(f"Edited original message {message_to_edit.message_id} to show 'Working...' status for query {query.id}")
         else:
-             # This case should be rare if query.message exists, but handle defensively
              logger.warning(f"Original message (query.message) not found for query {query.id}. Cannot edit, will send new status message.")
-             raise ValueError("Original message object missing") # Force fallback to sending new message
+             raise ValueError("Original message object missing")
     except (TimedOut, Exception) as e:
-        # If editing fails (e.g., message too old, deleted, rate limit), try sending a new message
         logger.warning(f"Could not edit original message {message_to_edit.message_id if message_to_edit else 'N/A'} for query {query.id}: {e!r}. Attempting to send a new status message.")
-        message_to_edit = None # Ensure we don't try to delete this later if editing failed
+        message_to_edit = None
         try:
             status_message_sent = await context.bot.send_message(chat_id=user.id, text=processing_message_text)
             logger.debug(f"Sent new status message {status_message_sent.message_id} to user {user.id}.")
         except TimedOut:
             logger.error(f"Timeout sending NEW 'Working...' status message to user {user.id}. Processing continues without feedback.")
-            # User won't know bot is working - proceed anyway, hope for the best.
         except Exception as send_err:
             logger.error(f"Failed sending NEW 'Working...' status message to user {user.id}: {send_err}. Processing continues without feedback.")
-            # As above.
 
-    # --- Main Content Fetching and Summarization ---
     content = None
-    user_feedback_message = None # Holds error/status messages for the user
-    success = False              # Tracks if we successfully sent a summary
+    user_feedback_message = None
+    success = False
 
     try:
-        # Send 'typing' action to indicate activity
         try:
             logger.debug(f"Sending 'typing' chat action to chat {user.id}")
             await context.bot.send_chat_action(chat_id=user.id, action='typing')
         except TimedOut: logger.warning(f"Timeout sending 'typing' action for user {user.id}.")
         except Exception as ca_err: logger.warning(f"Failed sending 'typing' action for user {user.id}: {ca_err}")
 
-        # --- Determine Content Type and Fetch ---
         is_yt = is_youtube_url(url)
         logger.debug(f"URL ({url}) is YouTube: {is_yt} (User: {user.id})")
 
@@ -734,18 +671,15 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
                 logger.warning(f"Failed to extract YouTube video ID from URL: {url} (User: {user.id})")
                 user_feedback_message = "⚠️ Sorry, I couldn't identify a valid YouTube video ID in the link you provided."
         else:
-            # --- Website Scraping ---
             logger.info(f"Attempting website scrape (Requests/BS4) for URL: {url} (User: {user.id})")
             content = await get_website_content_via_requests(url)
             if content:
                 logger.info(f"Website scrape successful (Requests/BS4). Length: {len(content)} (User: {user.id})")
-                # Content found, no need for feedback message yet
             else:
                 logger.warning(f"Primary website scrape failed for {url} (User: {user.id}). Trying fallback API.")
                 if current_urltotext_key:
-                    # Send typing again if first scrape failed and we try another method
                     try: await context.bot.send_chat_action(chat_id=user.id, action='typing'); logger.debug("Sent typing before fallback scrape.")
-                    except: pass # Ignore if fails
+                    except: pass
 
                     logger.info(f"Attempting website scrape via URLToText API for: {url} (User: {user.id})")
                     content = await get_website_content_via_urltotext_api(url, current_urltotext_key)
@@ -755,51 +689,44 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
                         logger.warning(f"Fallback website scrape (URLToText API) also failed for {url} (User: {user.id}).")
                         user_feedback_message = "⚠️ Sorry, I couldn't fetch the content from that website using available methods. It might be protected or structured in a way I can't parse."
                 else:
-                    # Fallback key missing
                     logger.warning(f"Primary scrape failed and URLToText API key not configured. Cannot fallback for {url} (User: {user.id}).")
                     user_feedback_message = "⚠️ Sorry, I couldn't fetch the content from that website, and the fallback service isn't configured."
 
-        # --- Generate Summary if Content Was Fetched ---
         if content:
             logger.info(f"Content fetched (Length: {len(content)}). Generating '{summary_type}' summary for user {user.id}.")
-            # Send typing before potentially long AI call
             try: await context.bot.send_chat_action(chat_id=user.id, action='typing'); logger.debug("Sent typing before AI summary generation.")
             except: pass
 
             summary = await generate_summary(content, summary_type, current_openrouter_key)
 
-            # Check if summary generation returned an error message
             if summary.startswith("Error:") or summary.startswith("Sorry,"):
                 logger.warning(f"AI summary generation failed for user {user.id}. Reason: {summary}")
-                user_feedback_message = f"⚠️ {summary}" # Use the error message from generate_summary
+                user_feedback_message = f"⚠️ {summary}"
             else:
-                # --- Summary Success - Send to User ---
                 logger.info(f"Summary generated successfully for user {user.id}. Length: {len(summary)}. Sending result.")
                 try:
                     await context.bot.send_message(
                         chat_id=user.id,
                         text=summary,
-                        parse_mode=ParseMode.MARKDOWN, # Assuming AI generates markdown for points
+                        parse_mode=ParseMode.MARKDOWN,
                         link_preview_options={'is_disabled': True}
                     )
                     success = True
-                    user_feedback_message = None # Clear any previous fetching error message
+                    user_feedback_message = None
                     logger.info(f"Successfully sent summary to user {user.id}.")
                 except TimedOut:
                     logger.error(f"Timeout sending final summary message to user {user.id}.")
                     user_feedback_message = "⚠️ Sorry, there was a timeout while trying to send you the final summary."
-                    success = False # Mark as failed if sending timed out
+                    success = False
                 except Exception as send_final_err:
                     logger.error(f"Failed sending final summary to user {user.id}: {send_final_err}", exc_info=True)
                     user_feedback_message = "⚠️ Sorry, an unexpected error occurred while sending the final summary."
-                    success = False # Mark as failed
+                    success = False
 
         elif not user_feedback_message:
-             # If content is None, but no specific error message was set above, set a generic one.
              logger.warning(f"Content retrieval resulted in None, but no specific user feedback message was set. URL: {url} (User: {user.id})")
              user_feedback_message = "⚠️ Sorry, I couldn't retrieve any usable content from the link provided."
 
-        # --- Send Final Feedback Message if Processing Failed ---
         if user_feedback_message and not success:
             logger.warning(f"Processing failed or summary sending failed for user {user.id}. Sending feedback: {user_feedback_message}")
             try:
@@ -810,114 +737,79 @@ async def handle_summary_type_callback(update: Update, context: ContextTypes.DEF
                  logger.error(f"Failed sending final FAILURE feedback message to user {user.id}: {send_feedback_err}")
 
     except Exception as e:
-        # Catch-all for unexpected errors during the main processing block
         logger.error(f"Unexpected critical error during callback processing for user {user.id}, URL {url}: {e}", exc_info=True)
         try:
-            # Send a generic error message to the user
             await context.bot.send_message(chat_id=user.id, text="❌ Oops! An unexpected internal error occurred while processing your request. The issue has been logged.")
         except TimedOut:
             logger.error(f"Timeout sending CRITICAL internal error feedback message to user {user.id}.")
         except Exception as final_err:
-            # If even sending the error message fails, log it.
             logger.error(f"Failed sending CRITICAL internal error feedback message to user {user.id}: {final_err}")
-        # Ensure success is False if we hit this block
         success = False
 
     finally:
-        # --- Clean up Status Message(s) ---
         logger.debug(f"Cleaning up status message(s) for user {user.id}, query {query.id}. Success={success}")
         try:
             if status_message_sent:
-                # If we sent a separate "Working..." message, delete it regardless of success/failure
-                # as the final result or error message has been (or attempted to be) sent.
                 await context.bot.delete_message(chat_id=user.id, message_id=status_message_sent.message_id)
                 logger.debug(f"Deleted separate status message {status_message_sent.message_id} for user {user.id}.")
             elif message_to_edit:
-                # If we edited the original message with the buttons...
                 if success:
-                    # If processing succeeded, delete the "Working..." message.
                     await query.delete_message()
                     logger.debug(f"Processing succeeded. Deleted original (edited) message {message_to_edit.message_id} for query {query.id}.")
                 else:
-                    # If processing failed, *don't* delete the message.
-                    # It either still shows "Working..." (if sending final error failed)
-                    # or it might show an error message if edit_message_text was used for that.
-                    # Let's try to edit it one last time to show a generic failure if no specific feedback was sent.
-                    # This is complex, maybe just leave it as is for simplicity.
                     logger.debug(f"Processing failed. Leaving edited message {message_to_edit.message_id} in place for query {query.id}.")
-                    # Optional: Try one last edit to show failure if needed, but might be overkill
-                    # if not user_feedback_message: # Only if no other error was sent
-                    #    try: await query.edit_message_text("❌ Processing failed.")
-                    #    except: pass # Ignore errors here
-
-            # If message_to_edit was None (original edit failed) and status_message_sent was None (sending new status failed), there's nothing to delete here.
 
         except TimedOut:
             logger.warning(f"Timeout attempting to delete status/button message for user {user.id}, query {query.id}.")
         except Exception as del_e:
-            # Log deletion errors as warnings, not critical if cleanup fails.
-            # Common error: message already deleted or trying to delete too late.
             logger.warning(f"Could not delete status/button message for user {user.id}, query {query.id}: {del_e!r}")
 
-        # Log the completion of the callback handling
         logger.info(f"Finished handling callback query {query.id} for user {user.id}. Overall Success: {success}")
 
 
 async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Log Errors caused by Updates."""
     logger.error(f"Exception while handling an update: {context.error}", exc_info=context.error)
-    # Add specific error type handling if needed (e.g., NetworkError, TimedOut)
     if isinstance(context.error, TimedOut):
         logger.warning("A timeout error occurred in PTB communication.")
     elif isinstance(context.error, NetworkError):
         logger.warning(f"A network error occurred: {context.error}")
-    # Consider notifying admin or user for specific critical errors if appropriate
 
-# --- Bot Setup Function (Modified: Increased Pool/Timeouts) ---
+# --- Bot Setup Function (Corrected: Removed invalid 'limits' param for PTB v20) ---
 async def setup_bot_config() -> Application:
-    """Configures the PTB Application with custom HTTPX settings."""
+    """Configures the PTB Application with custom HTTPX settings for PTB v20.x."""
     logger.info("Configuring Telegram Application...")
     if not TELEGRAM_TOKEN:
         logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable not found.")
         raise ValueError("TELEGRAM_TOKEN environment variable not set.")
 
-    # --- Configure HTTPX client settings ---
+    # --- Configure HTTPX client settings (Timeouts ONLY for PTB v20) ---
     connect_timeout = 10.0 # Slightly higher connect timeout
-    # --- INCREASED TIMEOUTS AND POOL SIZE ---
     read_timeout = 30.0  # Increased timeout for reading response
     write_timeout = 30.0 # Increased timeout for sending request
     pool_timeout = 30.0  # Increased timeout for getting connection from pool
-    connection_pool_size = 50 # Significantly increased pool size
+    # NOTE: PTB v20.x HTTPXRequest does not allow setting pool *size* directly here.
+    # It will use the httpx default (usually 10).
 
-    logger.info(f"Creating PTB HTTPXRequest with settings: "
+    logger.info(f"Creating PTB HTTPXRequest (v20 compatible) with settings: "
                 f"connect_timeout={connect_timeout}, read_timeout={read_timeout}, "
-                f"write_timeout={write_timeout}, pool_timeout={pool_timeout}, "
-                f"pool_size={connection_pool_size}")
-
-    # Create httpx.Limits object
-    custom_limits = httpx.Limits(
-        max_connections=connection_pool_size,
-        max_keepalive_connections=connection_pool_size # Keepalive same as max
-        # keepalive_expiry=60.0 # Optional: Keep idle connections open longer (seconds)
-    )
+                f"write_timeout={write_timeout}, pool_timeout={pool_timeout}. "
+                f"(Pool size uses httpx default)")
 
-    # Create a custom request object with these settings
+    # Create a custom request object with ONLY the supported timeout parameters
     custom_request = HTTPXRequest(
         connect_timeout=connect_timeout,
         read_timeout=read_timeout,
         write_timeout=write_timeout,
         pool_timeout=pool_timeout,
-        limits=custom_limits, # Use the Limits object here
-        http_version="1.1" # HTTP/1.1 is usually fine, HTTP/2 might be slightly faster if supported end-to-end
+        # REMOVED: limits=custom_limits, <<<--- This was the error
+        http_version="1.1"
     )
 
     # Use Application.builder() and pass the custom request object
     application_builder = Application.builder().token(TELEGRAM_TOKEN)
     application_builder.request(custom_request)
-    # Also apply to get_updates if you were using polling (webhook doesn't use this heavily)
-    # application_builder.get_updates_request(custom_request)
-    # Apply connection pool settings globally if needed (less common now with direct request object)
-    # application_builder.pool_timeout(pool_timeout) # This might be redundant if set in HTTPXRequest
+    # application_builder.get_updates_request(custom_request) # Apply if using polling
 
     # Build the application instance
     application = application_builder.build()
@@ -925,11 +817,8 @@ async def setup_bot_config() -> Application:
     # --- Register Handlers ---
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("help", help_command))
-    # Handles non-command text messages that might contain a URL
     application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_potential_url))
-    # Handles the button clicks ('paragraph' or 'points')
     application.add_handler(CallbackQueryHandler(handle_summary_type_callback))
-    # Global error handler
     application.add_error_handler(error_handler)
 
     logger.info("Telegram application handlers configured.")
@@ -941,51 +830,38 @@ async def lifespan(app: Starlette):
     """Handles PTB startup and shutdown during ASGI lifespan."""
     global ptb_app
     logger.info("ASGI Lifespan: Startup sequence initiated...")
-    # loop = asyncio.get_running_loop() # Not usually needed directly
 
     try:
-        # --- Setup and Initialize PTB Application ---
         ptb_app = await setup_bot_config()
         logger.info("PTB Application object configured. Initializing...")
-        await ptb_app.initialize() # Initialize application components (e.g., bot instance)
+        await ptb_app.initialize()
         logger.info("PTB Application initialized. Starting background tasks (e.g., job queue)...")
-        # Start PTB's internal tasks but not polling (we use webhook)
         await ptb_app.start()
-        if ptb_app.updater: ptb_app.updater.stop() # Ensure polling is stopped if accidentally started
+        if ptb_app.updater: ptb_app.updater.stop() # Ensure polling is stopped
         bot_instance = ptb_app.bot
         bot_info = await bot_instance.get_me()
         logger.info(f"PTB Application started successfully. Bot ID: {bot_info.id}, Username: @{bot_info.username}")
 
-        # --- Set Webhook ---
-        # Ensure SPACE_HOST is correctly set in Hugging Face Space secrets
         WEBHOOK_URL_BASE = os.environ.get("SPACE_HOST")
         if WEBHOOK_URL_BASE:
-            # Ensure it's a proper HTTPS URL
             if not WEBHOOK_URL_BASE.startswith("https://"): WEBHOOK_URL_BASE = f"https://{WEBHOOK_URL_BASE}"
-            webhook_path = "/webhook" # Must match the route defined later
+            webhook_path = "/webhook"
             full_webhook_url = f"{WEBHOOK_URL_BASE.rstrip('/')}{webhook_path}"
 
             logger.info(f"Attempting to set Telegram webhook to: {full_webhook_url}")
-            # Short delay can sometimes help prevent race conditions on startup
             await asyncio.sleep(2.0)
             try:
-                # Set the webhook, specifying allowed updates can reduce load
                 await bot_instance.set_webhook(
                     url=full_webhook_url,
-                    allowed_updates=Update.ALL_TYPES, # Or specify like [Update.MESSAGE, Update.CALLBACK_QUERY]
-                    # secret_token="YOUR_SECRET_TOKEN" # Recommended for security if possible
-                    # drop_pending_updates=True # Optional: Ignore updates sent while bot was down
+                    allowed_updates=Update.ALL_TYPES,
                 )
-                # Verify webhook setup
                 webhook_info = await bot_instance.get_webhook_info()
                 if webhook_info.url == full_webhook_url:
                     logger.info(f"Telegram webhook set successfully! Current info: {webhook_info}")
                 else:
                     logger.error(f"Webhook URL mismatch after setting! Expected '{full_webhook_url}', Got: {webhook_info.url}. Info: {webhook_info}")
             except RetryAfter as e:
-                 # This can happen if multiple workers try to set the webhook simultaneously
                  logger.warning(f"Webhook setting throttled by Telegram (RetryAfter: {e.retry_after}s). Another instance likely succeeded or try again later.")
-                 # Optionally check info again after delay
                  await asyncio.sleep(e.retry_after or 2)
                  webhook_info = await bot_instance.get_webhook_info()
                  logger.info(f"Webhook info after RetryAfter delay: {webhook_info}")
@@ -999,29 +875,24 @@ async def lifespan(app: Starlette):
 
     except Exception as startup_err:
         logger.critical(f"CRITICAL ERROR during ASGI application startup: {startup_err}", exc_info=True)
-        # Re-raise the exception to potentially stop the ASGI server from starting improperly
         raise
     finally:
-        # --- Shutdown Sequence ---
         logger.info("ASGI Lifespan: Shutdown sequence initiated...")
         if ptb_app:
             bot_username = ptb_app.bot.username if ptb_app.bot else "N/A"
             logger.info(f"PTB App instance found for @{bot_username}. Checking if running...")
-            # Check internal state if available (e.g., ptb_app.running might exist in future versions)
-            # Using _running is internal, but often the only way
             is_running = getattr(ptb_app, '_running', False) or getattr(ptb_app, 'running', False)
             if is_running:
                 try:
                     logger.info("Stopping PTB Application's background tasks...")
-                    await ptb_app.stop() # Stop internal tasks like JobQueue
+                    await ptb_app.stop()
                     logger.info("Shutting down PTB Application connections and resources...")
-                    await ptb_app.shutdown() # Clean up resources (e.g., close HTTPX client)
+                    await ptb_app.shutdown()
                     logger.info("PTB Application shut down gracefully.")
                 except Exception as shutdown_err:
                     logger.error(f"Error during PTB Application shutdown: {shutdown_err}", exc_info=True)
             else:
                  logger.warning("PTB Application instance exists but was not marked as running at shutdown.")
-                 # Attempt shutdown anyway just in case resources need cleaning
                  try: await ptb_app.shutdown()
                  except Exception: logger.error("Error during shutdown of non-running PTB app.", exc_info=True)
         else:
@@ -1030,8 +901,6 @@ async def lifespan(app: Starlette):
 
 
 # --- Flask App Setup (for Webhook Route) ---
-# We use Flask just for its familiarity in defining the route,
-# but it runs within Starlette's ASGI context via WSGIMiddleware.
 flask_core_app = Flask(__name__)
 logger.info("Core Flask app instance created (used by Starlette for routing).")
 
@@ -1042,7 +911,6 @@ def index():
     logger.debug("Health check endpoint '/' accessed.")
     bot_status = "Unknown / Not Initialized"
     if ptb_app and ptb_app.bot:
-        # Check internal state again (might have changed)
         is_running = getattr(ptb_app, '_running', False) or getattr(ptb_app, 'running', False)
         bot_status = f"Running (@{ptb_app.bot.username})" if is_running else f"Initialized/Stopped (@{ptb_app.bot.username})"
     return f"Telegram Bot Summarizer - Status: {bot_status} - Listening via Starlette/Uvicorn."
@@ -1050,60 +918,43 @@ def index():
 @flask_core_app.route('/webhook', methods=['POST'])
 async def webhook() -> Response:
     """Webhook endpoint called by Telegram."""
-    global ptb_app # Ensure we're using the global instance initialized by lifespan
+    global ptb_app
 
     if not ptb_app:
         logger.error("Webhook triggered, but PTB Application instance (ptb_app) is None. Lifespan likely failed.")
-        # Return 503 Service Unavailable
         return Response('Bot service is not configured or failed during startup.', status=503)
 
-    # Check internal state (safer than assuming ptb_app implies running)
     is_running = getattr(ptb_app, '_running', False) or getattr(ptb_app, 'running', False)
     if not is_running:
         logger.error("Webhook triggered, but PTB Application is not currently running.")
-        # Return 503 Service Unavailable
         return Response('Bot service is initialized but not actively running.', status=503)
 
-    # Proceed with processing the update
     logger.debug("Webhook endpoint received POST request from Telegram.")
     try:
-        # Use Flask's request object to get JSON data
         update_data = await request.get_json()
         if not update_data:
             logger.warning("Received empty or non-JSON data on webhook.")
             return Response('Bad Request: Expected JSON payload.', status=400)
 
-        # Deserialize JSON into a Telegram Update object
         update = Update.de_json(update_data, ptb_app.bot)
         logger.debug(f"Processing update_id: {update.update_id} via webhook route.")
-
-        # Process the update using PTB's internal mechanisms
-        # This will dispatch it to the correct handler (CommandHandler, MessageHandler, etc.)
         await ptb_app.process_update(update)
-
         logger.debug(f"Finished processing update_id: {update.update_id}")
-        # Return 200 OK to Telegram to acknowledge receipt
         return Response('ok', status=200)
 
     except json.JSONDecodeError:
         logger.error("Failed to decode JSON from Telegram webhook request.", exc_info=True)
         return Response('Bad Request: Invalid JSON format.', status=400)
     except Exception as e:
-        # Catch potential errors during Update.de_json or ptb_app.process_update
         logger.error(f"Error processing update in webhook handler: {e}", exc_info=True)
-        # Return 500 Internal Server Error to Telegram
-        # Telegram will likely retry sending the update later
         return Response('Internal Server Error processing update.', status=500)
 
 
 # --- Create Starlette ASGI Application ---
-# This is the main application object that Uvicorn/Gunicorn will run.
 app = Starlette(
-    debug=False, # Set debug based on environment if needed, but generally False in prod
-    lifespan=lifespan, # Hook into the lifespan context manager for startup/shutdown
+    debug=False,
+    lifespan=lifespan,
     routes=[
-        # Mount the Flask app under the root path. Starlette handles requests
-        # and forwards relevant ones ('/') and ('/webhook') to the Flask app.
         Mount("/", app=WSGIMiddleware(flask_core_app))
     ]
 )
@@ -1111,9 +962,6 @@ logger.info("Starlette ASGI application created, configured with lifespan and Fl
 
 
 # --- Development Server Execution Block ---
-# This block is ONLY for running the Flask app directly for basic testing
-# WITHOUT the proper ASGI lifespan management (PTB won't start correctly here).
-# DO NOT use this for deployment. Use `gunicorn main:app` or `uvicorn main:app`.
 if __name__ == '__main__':
     logger.warning("=" * 50)
     logger.warning(" RUNNING SCRIPT DIRECTLY (using __main__) ".center(50, "="))
@@ -1129,9 +977,6 @@ if __name__ == '__main__':
     if not TELEGRAM_TOKEN:
         logger.critical("CRITICAL: TELEGRAM_TOKEN environment variable missing. Aborting direct Flask start.")
     else:
-        # Get port from environment or default to 8080 for local dev
         local_port = int(os.environ.get('PORT', 8080))
         logger.info(f"Starting Flask development server on http://0.0.0.0:{local_port}")
-        # Run the Flask app directly (no Starlette, no lifespan, no PTB)
-        # use_reloader=False is important if debugging PTB setup elsewhere
         flask_core_app.run(host='0.0.0.0', port=local_port, debug=True, use_reloader=False)