Update app.py

app.py

@@ -5,10 +5,12 @@ from telethon import TelegramClient
 from telethon.errors import SessionPasswordNeededError, PhoneCodeInvalidError, AuthKeyError
 from huggingface_hub import upload_file
 from dotenv import load_dotenv
-from fastapi import FastAPI, Form, HTTPException
-from fastapi.responses import HTMLResponse, FileResponse
+from fastapi import FastAPI, Form, Request, status
+from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse
 from fastapi.staticfiles import StaticFiles
-import uvicorn
+from fastapi.templating import Jinja2Templates
+from fastapi.middleware.cors import CORSMiddleware
+import threading
 
 # === Load secrets from .env ===
 load_dotenv()
@@ -46,7 +48,6 @@ os.makedirs("downloads", exist_ok=True)
 def upload_to_dataset(filepath):
     if not HF_TOKEN or not REPO_ID:
         return False, f"❌ Missing Hugging Face credentials"
-    
     try:
         upload_file(
             path_or_fileobj=filepath,
@@ -61,37 +62,34 @@ def upload_to_dataset(filepath):
         logging.error(f"[!] Upload failed: {filepath} — {e}")
         return False, f"❌ Upload failed: {os.path.basename(filepath)} — {e}"
 
-# === Main file processing logic with improved error handling ===
+# === Main file processing logic ===
 async def process_filenames(name_input):
     if not client:
         return "❌ Error: Telegram client not initialized. Please check your API credentials."
-    
+
     if not CHANNEL:
         return "❌ Error: Channel username not configured."
-    
+
     try:
-        # Check if client is already connected
         if not client.is_connected():
             await client.connect()
-        
-        # Check if we're authorized
+
         if not await client.is_user_authorized():
             return "❌ Error: Telegram client not authorized. This application requires a pre-authenticated session file."
-        
+
         filenames = [name.strip().lower() for name in name_input.replace(",", "\n").splitlines() if name.strip()]
         results = []
         found = set()
 
-        # Use a more conservative approach to message iteration
         try:
             messages = []
-            async for msg in client.iter_messages(CHANNEL, limit=300):
+            async for msg in client.iter_messages(CHANNEL, limit=30000):
                 messages.append(msg)
         except Exception as e:
             logging.error(f"Error iterating messages: {e}")
             return f"❌ Error accessing channel messages: {str(e)}"
 
-        for i, msg in enumerate(messages):
+        for msg in messages:
             if msg.media and msg.file:
                 fname = msg.file.name or f"file_{msg.id}{msg.file.ext}"
 
@@ -118,65 +116,59 @@ async def process_filenames(name_input):
                 results.append(f"❌ Not found: {name}")
 
         return "\n".join(results) if results else "❌ No files matched."
-    
+
     except AuthKeyError:
-        logging.error("Auth key error - session may be corrupted")
         return "❌ Error: Session authentication failed. The session file may be corrupted or expired."
     except SessionPasswordNeededError:
-        logging.error("Two-factor authentication required")
         return "❌ Error: Two-factor authentication is enabled. This application requires a pre-authenticated session."
     except EOFError as e:
-        logging.error(f"EOF Error: {e}")
-        return "❌ Error: Connection interrupted. This may be due to network issues or session problems."
+        return f"❌ Error: Connection interrupted. {e}"
     except Exception as e:
-        logging.error(f"Error in process_filenames: {e}")
         return f"❌ Error: {str(e)}"
 
-# === FastAPI App ===
-app = FastAPI(title="Hugging Face Uploader", description="Upload files from Telegram to Hugging Face datasets")
+def run_async_in_thread(coro):
+    def run_in_thread():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(coro)
+        finally:
+            loop.close()
 
-@app.get("/", response_class=HTMLResponse)
-async def index():
-    """Serve the main HTML page"""
-    try:
-        with open("index.html", "r", encoding="utf-8") as f:
-            return HTMLResponse(content=f.read())
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail="index.html not found")
+    import concurrent.futures
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future = executor.submit(run_in_thread)
+        return future.result()
 
-@app.get("/style.css")
-async def get_css():
-    """Serve the CSS file"""
-    return FileResponse("style.css", media_type="text/css")
+# === FastAPI App ===
+basedir = os.path.abspath(os.path.expanduser("~"))
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-@app.get("/script.js")
-async def get_js():
-    """Serve the JavaScript file"""
-    return FileResponse("script.js", media_type="application/javascript")
+app.mount("/static", StaticFiles(directory=basedir), name="static")
+templates = Jinja2Templates(directory=basedir)
 
-@app.post("/upload")
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/upload", response_class=PlainTextResponse)
 async def upload(filenames: str = Form(...)):
-    """Handle file upload requests"""
-    try:
-        if not filenames.strip():
-            raise HTTPException(status_code=400, detail="❌ Error: No filenames provided")
-        
-        # Check if credentials are configured
-        if not client:
-            raise HTTPException(status_code=500, detail="❌ Error: Application not configured. Please set up your environment variables with API credentials.")
-        
-        # Process filenames using the async function
-        results = await process_filenames(filenames)
-        return {"results": results}
-    
-    except Exception as e:
-        logging.error(f"Error in upload route: {e}")
-        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")
+    if not client:
+        return PlainTextResponse("\u274c Error: App not configured.", status_code=500)
+    results = run_async_in_thread(process_filenames(filenames))
+    return results
 
-@app.get("/health")
+@app.get("/health", response_class=JSONResponse)
 async def health():
-    """Health check endpoint"""
-    status = {
+    return {
         "status": "healthy",
         "message": "Hugging Face Uploader is running",
         "configured": {
@@ -184,79 +176,30 @@ async def health():
             "huggingface": bool(HF_TOKEN and REPO_ID),
             "channel": bool(CHANNEL)
         },
-        "files": {
-            "index_html_exists": os.path.exists("index.html"),
-            "style_css_exists": os.path.exists("style.css"),
-            "script_js_exists": os.path.exists("script.js"),
-            "session_file_exists": os.path.exists("my_session.session")
+        "paths": {
+            "basedir": basedir,
+            "template_folder": basedir,
+            "static_folder": basedir
         }
     }
-    return status
 
-@app.get("/config")
+@app.get("/config", response_class=JSONResponse)
 async def config():
-    """Show configuration status"""
-    config_status = {
+    return {
         "API_ID": "✅ Set" if API_ID else "❌ Missing",
-        "API_HASH": "✅ Set" if API_HASH else "❌ Missing", 
+        "API_HASH": "✅ Set" if API_HASH else "❌ Missing",
         "HF_TOKEN": "✅ Set" if HF_TOKEN else "❌ Missing",
         "CHANNEL_USERNAME": "✅ Set" if CHANNEL else "❌ Missing",
         "DATASET_REPO": "✅ Set" if REPO_ID else "❌ Missing"
     }
-    return config_status
 
-@app.get("/debug")
-async def debug():
-    """Debug endpoint to check file structure"""
-    import glob
-    
-    debug_info = {
-        "current_directory": os.getcwd(),
-        "files_in_current_dir": os.listdir('.'),
-        "html_exists": os.path.exists('index.html'),
-        "css_exists": os.path.exists('style.css'),
-        "js_exists": os.path.exists('script.js'),
-        "session_file_exists": os.path.exists('my_session.session'),
-        "downloads_folder_exists": os.path.exists('downloads'),
-        "log_file_exists": os.path.exists('upload.log')
-    }
-    
-    return debug_info
-
-@app.get("/session-info")
+@app.get("/session-info", response_class=JSONResponse)
 async def session_info():
-    """Check Telegram session status"""
-    if not client:
-        return {"error": "Client not initialized"}
-    
     try:
-        session_status = {
+        return {
             "session_file_exists": os.path.exists('my_session.session'),
             "client_initialized": bool(client),
             "session_file_size": os.path.getsize('my_session.session') if os.path.exists('my_session.session') else 0
         }
-        return session_status
     except Exception as e:
         return {"error": str(e)}
-
-if __name__ == '__main__':
-    print("Starting Hugging Face Uploader with FastAPI...")
-    print("Configuration status:")
-    print(f"  API_ID: {'✅ Set' if API_ID else '❌ Missing'}")
-    print(f"  API_HASH: {'✅ Set' if API_HASH else '❌ Missing'}")
-    print(f"  HF_TOKEN: {'✅ Set' if HF_TOKEN else '❌ Missing'}")
-    print(f"  CHANNEL_USERNAME: {'✅ Set' if CHANNEL else '❌ Missing'}")
-    print(f"  DATASET_REPO: {'✅ Set' if REPO_ID else '❌ Missing'}")
-    print(f"\nFile structure:")
-    print(f"  index.html exists: {os.path.exists('index.html')}")
-    print(f"  style.css exists: {os.path.exists('style.css')}")
-    print(f"  script.js exists: {os.path.exists('script.js')}")
-    print(f"  Session file exists: {os.path.exists('my_session.session')}")
-    print("\n⚠️  IMPORTANT: This application requires a pre-authenticated Telegram session.")
-    print("   You must create the session file locally first, then upload it to your deployment.")
-    print("\nTo configure, set environment variables in your deployment environment.")
-    print("Visit http://localhost:7860 to use the application.")
-    
-    # Use port 7860 for Hugging Face Spaces compatibility
-    uvicorn.run(app, host="0.0.0.0", port=7860)
-