Update main.py

main.py

@@ -1,4 +1,4 @@
-# main.py (Revised: Starlette Lifespan + ptb_app._running fix)
+# main.py (Revised: Starlette Lifespan + ptb_app._running fix + HTTPX Config + Updated Prompts)
 import os
 import re
 import logging
@@ -25,8 +25,10 @@ from telegram.ext import (
 )
 from telegram.constants import ParseMode
 from telegram.error import NetworkError, RetryAfter # Import RetryAfter
+from telegram.request import HTTPXRequest # Import the request class
 
 # --- Other Libraries ---
+import httpx # Import httpx directly
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
 from bs4 import BeautifulSoup
@@ -41,14 +43,14 @@ logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     level=logging.DEBUG
 )
-logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING) # Keep httpx logs quieter unless debugging it
 if ApifyClient: logging.getLogger("apify_client").setLevel(logging.WARNING)
 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)
-logging.getLogger('starlette').setLevel(logging.INFO)
+logging.getLogger('uvicorn').setLevel(logging.INFO) # Uvicorn logs (incl. access)
+logging.getLogger('starlette').setLevel(logging.INFO) # Starlette logs
 logger = logging.getLogger(__name__)
 logger.info("Logging configured.")
 
@@ -71,6 +73,7 @@ SUPADATA_API_KEY = get_secret('SUPADATA_API_KEY')
 APIFY_API_TOKEN = get_secret('APIFY_API_TOKEN')
 logger.info("Secret loading attempt finished.")
 
+
 # --- Bot Logic Functions ---
 
 # Helper Functions
@@ -160,7 +163,7 @@ async def get_transcript_via_apify(video_url: str, api_token: str):
     params = {"token": api_token}
     payload = json.dumps({
         "urls": [video_url],
-        "outputFormat": "singleStringText", # Still request this primarily
+        "outputFormat": "singleStringText",
         "maxRetries": 3,
         "channelHandleBoolean": False,
         "channelNameBoolean": False,
@@ -331,23 +334,53 @@ async def get_website_content_via_urltotext_api(url: str, api_key: str):
     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
+# DeepSeek Summary Function (with updated prompts)
 async def generate_summary(text: str, summary_type: str, api_key: str) -> str:
     """Generates summary using DeepSeek via OpenRouter API."""
     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"
-    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
+
+    # --- UPDATED PROMPTS ---
+    if summary_type == "paragraph":
+        prompt = (
+            "You are an AI model designed to provide concise summaries using British English spellings. "
+            "Your output should be:\n"
+            "• Clear and simple, use a level of language and vocabulary such that someone who isn’t familiar with the topic mentioned would still be able to understand, keeping British spellings throughout.\n"
+            "• Use straightforward and understandable language. Avoid overly complex or advanced vocabulary.\n"
+            "• Presented in one paragraph.\n"
+            "• A summary that is no more than 85 words; ensure it remains concise.\n"
+            "• Consider the entire text’s content, not just the beginning or a few topics: give equal attention to all parts.\n"
+            "• Do not use em dash (– or —) symbols; use semicolons instead.\n\n"
+            "Now, please summarize the following text according to these rules:"
+        )
+    elif summary_type == "points":
+        prompt = (
+            "You are an AI model designed to provide concise summaries using British English spellings.\n"
+            "Your output should be:\n"
+            "• Clear and simple, use a level of language and vocabulary such that someone who isn’t familiar with the topic mentioned would still be able to understand, keeping British spellings throughout.\n"
+            "• Use straightforward and understandable language. Avoid overly complex or advanced vocabulary.\n"
+            "• Presented as clear, distinct bullet points (using '*' or '-' at the start of each point).\n"
+            "• Each point should highlight a key piece of information, finding, or main topic discussed.\n"
+            "• Consider the entire text’s content, not just the beginning or a few topics: give equal attention to all parts.\n"
+            "• Do not use em dash (– or —) symbols; use semicolons instead.\n\n"
+            "Now, please summarize the following text into bullet points according to these rules:"
+        )
+    else:
+        logger.error(f"Invalid summary_type '{summary_type}'.");
+        return f"Error: Invalid summary type ('{summary_type}')."
+    # --- END UPDATED PROMPTS ---
+
+    MAX_INPUT_LENGTH = 500000 # Keep practical limit
     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 ---"
-    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME")
+
+    space_host = os.environ.get("SPACE_HOST", "huggingface.co/spaces/YOUR_SPACE_NAME") # Replace with actual space if needed
     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)
@@ -476,25 +509,38 @@ async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE) -> N
     """Log Errors caused by Updates."""
     logger.error(f"Exception while handling an update: {context.error}", exc_info=context.error)
 
-# --- Bot Setup Function (Configure Only) ---
+# --- Bot Setup Function (Modified: Configure HTTPX Client) ---
 async def setup_bot_config() -> Application:
-    """Configures the PTB Application but does NOT initialize or start it."""
+    """Configures the PTB Application with custom HTTPX settings."""
     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.")
-    application = Application.builder().token(TELEGRAM_TOKEN).build()
+
+    httpx_settings = {
+        "timeout": httpx.Timeout(timeout=10.0, read=10.0, connect=5.0, pool=10.0),
+        "limits": httpx.Limits(max_keepalive_connections=10, max_connections=100, keepalive_expiry=15.0) # Increased expiry
+    }
+    logger.info(f"Creating PTB HTTPXRequest with settings: {httpx_settings}")
+    custom_request = HTTPXRequest(connection_pool_size=10, connect_timeout=5.0, read_timeout=10.0, http_version="1.1", httpx_settings=httpx_settings)
+
+    application_builder = Application.builder().token(TELEGRAM_TOKEN)
+    application_builder.request(custom_request)
+    application_builder.get_updates_request(custom_request)
+    application = application_builder.build()
+
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("help", help_command))
     application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_potential_url))
     application.add_handler(CallbackQueryHandler(handle_summary_type_callback))
     application.add_error_handler(error_handler)
+
     logger.info("Telegram handlers configured.")
     return application
 
 # --- ASGI Lifespan Context Manager ---
 @contextlib.asynccontextmanager
-async def lifespan(app: Starlette): # app argument is the Starlette instance
+async def lifespan(app: Starlette):
     """Handles PTB startup and shutdown during ASGI lifespan."""
     global ptb_app
     logger.info("ASGI Lifespan: Startup commencing...")
@@ -508,7 +554,6 @@ async def lifespan(app: Starlette): # app argument is the Starlette instance
         await ptb_app.start()
         logger.info(f"PTB App started. Bot details: {ptb_app.bot.username}")
 
-        # Set webhook after start
         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}"
@@ -516,9 +561,7 @@ async def lifespan(app: Starlette): # app argument is the Starlette instance
             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 asyncio.sleep(1.5) # Small delay before setting webhook
                 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}")
@@ -535,10 +578,8 @@ async def lifespan(app: Starlette): # app argument is the Starlette instance
         logger.critical(f"CRITICAL ERROR during ASGI startup: {startup_err}", exc_info=True)
         raise
     finally:
-        # --- Shutdown ---
         logger.info("ASGI Lifespan: Shutdown commencing...")
-        # Use the correct attribute to check if running before stopping/shutting down
-        if ptb_app and ptb_app._running: # <--- Use _running here too
+        if ptb_app and ptb_app._running: # Use _running
             try:
                 logger.info("Stopping PTB App...")
                 await ptb_app.stop()
@@ -547,10 +588,8 @@ async def lifespan(app: Starlette): # app argument is the Starlette instance
                 logger.info("PTB App shut down successfully.")
             except Exception as shutdown_err:
                 logger.error(f"Error during PTB shutdown: {shutdown_err}", exc_info=True)
-        elif ptb_app:
-             logger.warning("PTB App instance exists but was not running at shutdown.")
-        else:
-            logger.warning("No PTB App instance found at shutdown.")
+        elif ptb_app: logger.warning("PTB App instance exists but was not running at shutdown.")
+        else: logger.warning("No PTB App instance found at shutdown.")
         logger.info("ASGI Lifespan: Shutdown complete.")
 
 
@@ -564,27 +603,18 @@ def index():
     """Basic health check endpoint."""
     logger.debug("Health check '/' accessed.")
     bot_status = "UNKNOWN"
-    if ptb_app:
-        # --- CORRECTED CHECK ---
-        bot_status = "Running" if ptb_app._running else "Initialized/Stopped/Starting/Error"
-        # --- END CORRECTION ---
-    else:
-        bot_status = "Not Initialized"
+    if ptb_app: bot_status = "Running" if ptb_app._running else "Initialized/Stopped/Starting/Error" # Use _running
+    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: # Check if instance exists first
+    if not ptb_app:
         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}.")
+    if not ptb_app._running: # Use _running
+        logger.error("Webhook triggered, but PTB Application is Not Running.")
         return Response('Bot service not ready.', status=503)
 
     logger.debug("Webhook request received (POST)...")
@@ -593,7 +623,7 @@ async def webhook() -> Response:
             update_data = request.get_json()
             update = Update.de_json(update_data, ptb_app.bot)
             logger.debug(f"Processing update ID: {update.update_id} via webhook")
-            await ptb_app.process_update(update) # Queue/process the update
+            await ptb_app.process_update(update)
             logger.debug(f"Finished processing update ID: {update.update_id}")
             return Response('ok', status=200)
         except json.JSONDecodeError: logger.error("Failed JSON decode from Telegram."); return Response('Bad Request: Invalid JSON', status=400)