Update app.py

app.py

@@ -21,8 +21,6 @@ API_KEY = os.getenv("API_KEY", "default-key-123")
 MAX_TOKENS = 450
 DEVICE = "cpu"
 PORT = int(os.getenv("PORT", 7860))
-TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN", "")
-TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "")
 
 # Setup logging
 logging.basicConfig(
@@ -88,34 +86,6 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(lifespan=lifespan)
 
-async def send_telegram_message(message: str):
-    """Send message to Telegram"""
-    if not TELEGRAM_BOT_TOKEN or not TELEGRAM_CHAT_ID:
-        logger.warning("Telegram credentials not configured")
-        return False
-        
-    try:
-        url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
-        payload = {
-            "chat_id": TELEGRAM_CHAT_ID,
-            "text": message,
-            "parse_mode": "HTML",
-            "disable_web_page_preview": True
-        }
-        
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.post(url, json=payload)
-            if response.status_code == 200:
-                logger.info("📨 Telegram notification sent")
-                return True
-            else:
-                logger.error(f"❌ Telegram API error: {response.status_code} - {response.text}")
-                return False
-                
-    except Exception as e:
-        logger.error(f"❌ Telegram notification failed: {str(e)}")
-        return False
-
 def extract_topics(topic_input: Union[str, List[str]]) -> List[str]:
     """Extract and validate topics from input"""
     if isinstance(topic_input, str):
@@ -244,7 +214,7 @@ def generate_script(topic: str) -> str:
           "- Use conversational, engaging tone\n"
           "- End with strong, clear call-to-action\n\n"
     
-         "EXAMPLE FORMAT:\n"
+         "EXAMPLE FORFORMAT:\n"
          "[0:00-0:08] VISUAL: dramatic time-lapse of vibrant superfoods being prepared\n"
          "VOICEOVER: This one simple change can boost your energy by 200% in just 30 days\n\n"
     
@@ -304,10 +274,6 @@ async def process_job(job_id: str, topics_input: Union[str, List[str]], callback
             
         logger.info(f"🎯 Processing {len(topics)} topics: {topics}")
         
-        # Send start notification to Telegram
-        start_message = f"🚀 <b>Script Generation Started</b>\n\nTopics: {', '.join(topics[:3])}{'...' if len(topics) > 3 else ''}"
-        asyncio.create_task(send_telegram_message(start_message))
-        
         # Step 1: Generate a viral topic from the trends
         generated_topic = generate_topic_from_trends(topics)
         
@@ -326,19 +292,6 @@ async def process_job(job_id: str, topics_input: Union[str, List[str]], callback
         
         logger.info(f"✅ Completed job {job_id}")
         
-        # Send completion notification to Telegram
-        completion_message = f"""
-✅ <b>Script Generation Complete!</b>
-
-🏷️ <b>Generated Topic:</b> {generated_topic}
-
-📝 <b>Script Length:</b> {len(script)} characters
-🕒 <b>Estimated Video Duration:</b> 60 seconds
-
-🔗 <b>View in n8n:</b> Check your workflow for the complete script
-        """
-        asyncio.create_task(send_telegram_message(completion_message))
-        
         # Send webhook callback if URL provided
         if callback_url:
             try:
@@ -359,7 +312,10 @@ async def process_job(job_id: str, topics_input: Union[str, List[str]], callback
                         headers={"Content-Type": "application/json"}
                     )
                     
-                    logger.info(f"📨 Webhook status: {response.status_code}")
+                    if response.status_code >= 200 and response.status_code < 300:
+                        logger.info(f"📨 Webhook delivered successfully: {response.status_code}")
+                    else:
+                        logger.warning(f"⚠️ Webhook returned non-2xx status: {response.status_code}")
                     
             except Exception as e:
                 logger.error(f"❌ Webhook failed: {str(e)}")
@@ -368,10 +324,6 @@ async def process_job(job_id: str, topics_input: Union[str, List[str]], callback
         error_msg = f"Job failed: {str(e)}"
         logger.error(f"❌ Job {job_id} failed: {error_msg}")
         
-        # Send error notification to Telegram
-        error_message = f"❌ <b>Script Generation Failed</b>\n\nError: {str(e)}"
-        asyncio.create_task(send_telegram_message(error_message))
-        
         # Store failure information
         jobs[job_id] = {
             "status": "failed",
@@ -390,10 +342,11 @@ async def process_job(job_id: str, topics_input: Union[str, List[str]], callback
                             "status": "failed",
                             "error": error_msg,
                             "topics": extract_topics(topics_input) if topics_input else []
-                        }
+                        },
+                        headers={"Content-Type": "application/json"}
                     )
-            except Exception:
-                logger.error("Failed to send error webhook")
+            except Exception as e:
+                logger.error(f"Failed to send error webhook: {e}")
 
 @app.post("/api/submit")
 async def submit_job(
@@ -451,7 +404,8 @@ async def get_status(job_id: str, auth: bool = Depends(verify_api_key)):
     """Check job status"""
     if job_id not in jobs:
         raise HTTPException(status_code=404, detail="Job not found")
-    return jobs[job_id]
+    
+    return JSONResponse(jobs[job_id])
 
 @app.get("/health")
 async def health_check():
@@ -459,14 +413,14 @@ async def health_check():
     completed_jobs = [job for job in jobs.values() if job.get("status") == "complete"]
     avg_length = sum(job.get("script_length", 0) for job in completed_jobs) / max(1, len(completed_jobs))
     
-    return {
+    return JSONResponse({
         "status": "healthy",
         "model_loaded": generator.loaded,
         "total_jobs": len(jobs),
         "completed_jobs": len(completed_jobs),
         "failed_jobs": sum(1 for job in jobs.values() if job.get("status") == "failed"),
         "average_script_length": round(avg_length, 2)
-    }
+    })
 
 @app.get("/test/generation")
 async def test_generation(auth: bool = Depends(verify_api_key)):
@@ -474,7 +428,7 @@ async def test_generation(auth: bool = Depends(verify_api_key)):
     try:
         if not generator.loaded:
             if not generator.load_model():
-                return {"status": "error", "error": "Model failed to load"}
+                return JSONResponse({"status": "error", "error": "Model failed to load"})
         
         test_topics = [
             "Artificial Intelligence", 
@@ -492,7 +446,7 @@ async def test_generation(auth: bool = Depends(verify_api_key)):
         # Test script generation
         script = generate_script(generated_topic)
         
-        return {
+        return JSONResponse({
             "status": "success", 
             "test_topics": test_topics,
             "generated_topic": generated_topic,
@@ -500,39 +454,27 @@ async def test_generation(auth: bool = Depends(verify_api_key)):
             "script_preview": script[:300] + "..." if len(script) > 300 else script,
             "estimated_duration": "60 seconds",
             "quality": "good" if len(script) >= 800 else "needs improvement"
-        }
+        })
         
     except Exception as e:
         logger.error(f"❌ Test generation failed: {str(e)}")
-        return {"status": "error", "error": str(e)}
-
-@app.get("/test/telegram")
-async def test_telegram(auth: bool = Depends(verify_api_key)):
-    """Test Telegram notification"""
-    test_message = "🔔 <b>Test Notification</b>\n\nThis is a test message from your Script Generator API"
-    success = await send_telegram_message(test_message)
-    
-    return {
-        "status": "success" if success else "error",
-        "message": "Telegram test sent" if success else "Telegram test failed",
-        "bot_configured": bool(TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID)
-    }
+        return JSONResponse({"status": "error", "error": str(e)})
 
 @app.get("/")
 async def root():
     """Root endpoint"""
-    return {
-        "message": "Enhanced Video Script Generator API with Telegram Notifications",
-        "version": "2.1",
-        "features": "Generates viral topics from trends, creates scripts, and sends Telegram notifications",
+    return JSONResponse({
+        "message": "Video Script Generator API",
+        "version": "2.0",
+        "features": "Generates viral topics from trends and creates video scripts",
         "endpoints": {
             "submit_job": "POST /api/submit (with 'topics' array)",
             "check_status": "GET /api/status/{job_id}",
             "health": "GET /health",
-            "test_generation": "GET /test/generation",
-            "test_telegram": "GET /test/telegram"
+            "test_generation": "GET /test/generation"
         },
-    }
+        "status": "operational"
+    })
 
 if __name__ == "__main__":
     uvicorn.run(
@@ -540,5 +482,4 @@ if __name__ == "__main__":
         host="0.0.0.0",
         port=PORT,
         log_level="info"
-    )
-    
+    )