Update app.py

app.py

@@ -10,16 +10,23 @@ import uuid
 import mimetypes
 import numpy as np
 from PIL import Image
+import traceback
+
+# Real-ESRGAN imports with comprehensive error handling
+REALESRGAN_AVAILABLE = False
+REALESRGAN_ERROR = None
 
-# Real-ESRGAN imports with better error handling
 try:
     from realesrgan import RealESRGANer
     from basicsr.archs.rrdbnet_arch import RRDBNet
     REALESRGAN_AVAILABLE = True
-    print("✅ Real-ESRGAN available")
+    print("✅ Real-ESRGAN successfully imported")
 except ImportError as e:
-    REALESRGAN_AVAILABLE = False
+    REALESRGAN_ERROR = str(e)
     print(f"⚠️ Real-ESRGAN not available: {e}")
+except Exception as e:
+    REALESRGAN_ERROR = str(e)
+    print(f"❌ Real-ESRGAN import error: {e}")
 
 # Configuration
 UPLOAD_FOLDER = '/data/uploads'
@@ -30,6 +37,7 @@ MODEL_FOLDER = '/data/models'
 app_state = {
     "cuda_available": torch.cuda.is_available(),
     "realesrgan_available": REALESRGAN_AVAILABLE,
+    "realesrgan_error": REALESRGAN_ERROR,
     "processing_active": False,
     "logs": [],
     "processed_files": [],
@@ -45,178 +53,6 @@ def ensure_directories():
             os.makedirs(directory, exist_ok=True)
             print(f"✅ Directory verified: {directory}")
         except Exception as e:
-            info["storage_uploads"] = "Error"
-            info["storage_outputs"] = "Error"
-            info["upload_files_count"] = 0
-            info["output_files_count"] = 0
-        
-        return jsonify({"success": True, "data": info})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-@app.route('/api/upload', methods=['POST'])
-def api_upload():
-    """Upload and process file for 4K upscaling"""
-    try:
-        if 'file' not in request.files:
-            return jsonify({"success": False, "error": "No file provided"})
-        
-        file = request.files['file']
-        if file.filename == '':
-            return jsonify({"success": False, "error": "No file selected"})
-        
-        if file and allowed_file(file.filename):
-            file_id = str(uuid.uuid4())
-            filename = secure_filename(file.filename)
-            file_ext = filename.rsplit('.', 1)[1].lower()
-            
-            input_filename = f"{file_id}_input.{file_ext}"
-            input_path = os.path.join(UPLOAD_FOLDER, input_filename)
-            file.save(input_path)
-            
-            output_filename = f"{file_id}_4k.{file_ext}"
-            output_path = os.path.join(OUTPUT_FOLDER, output_filename)
-            
-            if file_ext in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp']:
-                upscale_image_4k(input_path, output_path)
-                media_type = "image"
-            elif file_ext in ['mp4', 'avi', 'mov', 'mkv']:
-                upscale_video_4k(input_path, output_path)
-                media_type = "video"
-            
-            log_message(f"📤 File uploaded: {filename}")
-            log_message(f"🎯 Starting 4K upscaling process...")
-            
-            return jsonify({
-                "success": True, 
-                "file_id": file_id,
-                "filename": filename,
-                "output_filename": output_filename,
-                "media_type": media_type,
-                "message": "Upload successful, processing started"
-            })
-        else:
-            return jsonify({"success": False, "error": "File type not allowed"})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-@app.route('/api/processing-status')
-def api_processing_status():
-    """Get processing status"""
-    return jsonify({
-        "success": True,
-        "processing": app_state["processing_active"],
-        "processed_files": app_state["processed_files"]
-    })
-
-@app.route('/api/download/<filename>')
-def api_download(filename):
-    """Download processed file"""
-    try:
-        file_path = os.path.join(OUTPUT_FOLDER, filename)
-        if os.path.exists(file_path):
-            mimetype = get_file_mimetype(filename)
-            return send_file(
-                file_path,
-                as_attachment=True,
-                download_name=f"4k_upscaled_{filename}",
-                mimetype=mimetype
-            )
-        else:
-            return jsonify({"error": "File not found"}), 404
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/preview/<filename>')
-def api_preview(filename):
-    """Preview processed file"""
-    try:
-        file_path = os.path.join(OUTPUT_FOLDER, filename)
-        if os.path.exists(file_path):
-            mimetype = get_file_mimetype(filename)
-            return send_file(file_path, mimetype=mimetype)
-        else:
-            return jsonify({"error": "File not found"}), 404
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/logs')
-def api_logs():
-    """Get application logs"""
-    return jsonify({
-        "success": True,
-        "logs": app_state["logs"]
-    })
-
-@app.route('/api/clear-logs', methods=['POST'])
-def api_clear_logs():
-    """Clear application logs"""
-    app_state["logs"] = []
-    log_message("🧹 Logs cleared")
-    return jsonify({"success": True, "message": "Logs cleared"})
-
-@app.route('/api/optimize-gpu', methods=['POST'])
-def api_optimize_gpu():
-    """Optimize GPU for processing"""
-    try:
-        success = optimize_gpu()
-        return jsonify({"success": success})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-@app.route('/api/init-realesrgan', methods=['POST'])
-def api_init_realesrgan():
-    """Initialize Real-ESRGAN manually"""
-    try:
-        if not REALESRGAN_AVAILABLE:
-            return jsonify({"success": False, "error": "Real-ESRGAN not available"})
-        
-        upscaler = initialize_realesrgan()
-        if upscaler:
-            return jsonify({"success": True, "message": "Real-ESRGAN initialized successfully"})
-        else:
-            return jsonify({"success": False, "error": "Failed to initialize Real-ESRGAN"})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-@app.route('/api/clear-cache', methods=['POST'])
-def api_clear_cache():
-    """Clear cache and processed files"""
-    try:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        
-        app_state["processed_files"] = []
-        log_message("🧹 Cache and history cleared")
-        
-        return jsonify({"success": True, "message": "Cache cleared"})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-if __name__ == '__main__':
-    # Initialize system
-    log_message("🚀 4K Upscaler starting...")
-    
-    try:
-        # Optimize GPU if available
-        if optimize_gpu():
-            log_message("✅ GPU optimization completed")
-        else:
-            log_message("⚠️ Using CPU mode")
-        
-        log_message("✅ 4K Upscaler ready")
-        log_message("📤 Upload images or videos to upscale to 4K resolution")
-        
-    except Exception as e:
-        log_message(f"❌ Initialization error: {str(e)}")
-        log_message("⚠️ Starting in fallback mode...")
-    
-    # Run application
-    try:
-        app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)
-    except Exception as e:
-        log_message(f"❌ Server startup error: {str(e)}")
-        print(f"Critical error: {str(e)}")
             print(f"⚠️ Error creating directory {directory}: {e}")
 
 def allowed_file(filename):
@@ -248,6 +84,7 @@ def log_message(message):
 def download_realesrgan_models():
     """Download Real-ESRGAN models if not present"""
     if not REALESRGAN_AVAILABLE:
+        log_message("❌ Real-ESRGAN not available for model download")
         return False
     
     models = {
@@ -267,15 +104,17 @@ def download_realesrgan_models():
                 except Exception as e:
                     log_message(f"❌ Failed to download {model_name}: {e}")
                     return False
+            else:
+                log_message(f"✅ Model {model_name} already exists")
         return True
     except Exception as e:
         log_message(f"❌ Error downloading models: {str(e)}")
         return False
 
 def initialize_realesrgan(model_name='RealESRGAN_x4plus', scale=4):
-    """Initialize Real-ESRGAN upscaler"""
+    """Initialize Real-ESRGAN upscaler with robust error handling"""
     if not REALESRGAN_AVAILABLE:
-        log_message("❌ Real-ESRGAN not available")
+        log_message(f"❌ Real-ESRGAN not available: {REALESRGAN_ERROR}")
         return None
     
     try:
@@ -290,6 +129,13 @@ def initialize_realesrgan(model_name='RealESRGAN_x4plus', scale=4):
                 log_message("❌ Failed to download models")
                 return None
         
+        # Verify model file
+        if not os.path.exists(model_path) or os.path.getsize(model_path) == 0:
+            log_message(f"❌ Model file invalid: {model_path}")
+            return None
+        
+        log_message(f"📁 Model file verified: {os.path.getsize(model_path) / (1024*1024):.1f}MB")
+        
         # Initialize model architecture
         if model_name == 'RealESRGAN_x4plus':
             model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
@@ -301,7 +147,7 @@ def initialize_realesrgan(model_name='RealESRGAN_x4plus', scale=4):
             log_message(f"❌ Unknown model: {model_name}")
             return None
         
-        # Always use CPU for compatibility
+        # Use CPU for maximum compatibility
         device = torch.device('cpu')
         log_message(f"🖥️ Using device: {device}")
         
@@ -310,13 +156,23 @@ def initialize_realesrgan(model_name='RealESRGAN_x4plus', scale=4):
             scale=netscale,
             model_path=model_path,
             model=model,
-            tile=200,  # Small tile size for CPU
+            tile=400,  # Reasonable tile size for CPU
             tile_pad=10,
             pre_pad=0,
             half=False,  # No half precision on CPU
             device=device
         )
         
+        # Test the upscaler with a small image
+        log_message("🧪 Testing Real-ESRGAN with sample image...")
+        test_img = np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8)
+        try:
+            _, _ = upscaler.enhance(test_img, outscale=2)
+            log_message("✅ Real-ESRGAN test successful")
+        except Exception as e:
+            log_message(f"❌ Real-ESRGAN test failed: {e}")
+            return None
+        
         app_state["upscaler"] = upscaler
         app_state["current_model"] = model_name
         log_message(f"✅ Real-ESRGAN initialized: {model_name} on {device}")
@@ -324,6 +180,7 @@ def initialize_realesrgan(model_name='RealESRGAN_x4plus', scale=4):
         
     except Exception as e:
         log_message(f"❌ Error initializing Real-ESRGAN: {str(e)}")
+        log_message(f"🔍 Traceback: {traceback.format_exc()}")
         app_state["upscaler"] = None
         app_state["current_model"] = None
         return None
@@ -359,10 +216,19 @@ def upscale_image_4k(input_path, output_path):
             
             start_time = time.time()
             
-            # Read image
-            img = cv2.imread(input_path, cv2.IMREAD_COLOR)
+            # Read image with error handling
+            try:
+                img = cv2.imread(input_path, cv2.IMREAD_COLOR)
+                if img is None:
+                    # Try with PIL as fallback
+                    pil_img = Image.open(input_path).convert('RGB')
+                    img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+            except Exception as e:
+                log_message(f"❌ Error reading image: {e}")
+                return
+            
             if img is None:
-                log_message("❌ Error: Could not read image")
+                log_message("❌ Error: Could not read image with any method")
                 return
             
             h, w = img.shape[:2]
@@ -372,27 +238,20 @@ def upscale_image_4k(input_path, output_path):
             method_used = "Unknown"
             
             # Try Real-ESRGAN first if available
-            if REALESRGAN_AVAILABLE:
+            if REALESRGAN_AVAILABLE and app_state["upscaler"] is not None:
                 try:
-                    if app_state["upscaler"] is None:
-                        log_message("🔧 Initializing Real-ESRGAN...")
-                        upscaler = initialize_realesrgan()
-                    else:
-                        upscaler = app_state["upscaler"]
-                    
-                    if upscaler is not None:
-                        log_message("🧠 Applying Real-ESRGAN neural upscaling...")
-                        output, _ = upscaler.enhance(img, outscale=4)
-                        cv2.imwrite(output_path, output)
-                        method_used = f"Real-ESRGAN ({app_state['current_model']})"
-                        success = True
-                        log_message("✅ Real-ESRGAN upscaling successful")
-                    else:
-                        log_message("⚠️ Real-ESRGAN initialization failed")
+                    log_message("🧠 Applying Real-ESRGAN neural upscaling...")
+                    output, _ = app_state["upscaler"].enhance(img, outscale=4)
+                    cv2.imwrite(output_path, output)
+                    method_used = f"Real-ESRGAN ({app_state['current_model']})"
+                    success = True
+                    log_message("✅ Real-ESRGAN upscaling successful")
                         
                 except Exception as e:
                     log_message(f"⚠️ Real-ESRGAN failed: {str(e)}")
                     log_message("🔄 Falling back to enhanced bicubic...")
+            else:
+                log_message("⚠️ Real-ESRGAN not available, using enhanced bicubic")
             
             # Fallback to enhanced bicubic if Real-ESRGAN failed or not available
             if not success:
@@ -481,33 +340,37 @@ def upscale_image_4k(input_path, output_path):
             
             if success:
                 # Verify output
-                final_img = cv2.imread(output_path)
-                if final_img is not None:
-                    final_h, final_w = final_img.shape[:2]
-                    processing_time = time.time() - start_time
-                    
-                    log_message(f"✅ Upscaling completed: {final_w}x{final_h}")
-                    log_message(f"📈 Scale factor: {final_w/w:.1f}x")
-                    log_message(f"⏱️ Processing time: {processing_time:.1f}s")
-                    log_message(f"🔧 Method used: {method_used}")
-                    
-                    # Add to processed files
-                    app_state["processed_files"].append({
-                        "input_file": os.path.basename(input_path),
-                        "output_file": os.path.basename(output_path),
-                        "original_size": f"{w}x{h}",
-                        "upscaled_size": f"{final_w}x{final_h}",
-                        "method": method_used,
-                        "processing_time": f"{processing_time:.1f}s",
-                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                    })
-                else:
-                    log_message("❌ Error: Output file could not be read")
+                try:
+                    final_img = cv2.imread(output_path)
+                    if final_img is not None:
+                        final_h, final_w = final_img.shape[:2]
+                        processing_time = time.time() - start_time
+                        
+                        log_message(f"✅ Upscaling completed: {final_w}x{final_h}")
+                        log_message(f"📈 Scale factor: {final_w/w:.1f}x")
+                        log_message(f"⏱️ Processing time: {processing_time:.1f}s")
+                        log_message(f"🔧 Method used: {method_used}")
+                        
+                        # Add to processed files
+                        app_state["processed_files"].append({
+                            "input_file": os.path.basename(input_path),
+                            "output_file": os.path.basename(output_path),
+                            "original_size": f"{w}x{h}",
+                            "upscaled_size": f"{final_w}x{final_h}",
+                            "method": method_used,
+                            "processing_time": f"{processing_time:.1f}s",
+                            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        })
+                    else:
+                        log_message("❌ Error: Output file could not be read")
+                except Exception as e:
+                    log_message(f"❌ Error verifying output: {e}")
             else:
                 log_message("❌ All upscaling methods failed")
                 
         except Exception as e:
             log_message(f"❌ Critical error in upscaling: {str(e)}")
+            log_message(f"🔍 Traceback: {traceback.format_exc()}")
         finally:
             app_state["processing_active"] = False
             if torch.cuda.is_available():
@@ -554,7 +417,7 @@ def upscale_video_4k(input_path, output_path):
                 frame_num += 1
                 
                 try:
-                    # Enhanced bicubic for video frames
+                    # Enhanced bicubic for video frames (faster than Real-ESRGAN)
                     upscaled_frame = cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_CUBIC)
                     
                     # Light sharpening
@@ -603,6 +466,7 @@ def upscale_video_4k(input_path, output_path):
                 
         except Exception as e:
             log_message(f"❌ Error processing video: {str(e)}")
+            log_message(f"🔍 Traceback: {traceback.format_exc()}")
         finally:
             app_state["processing_active"] = False
             if torch.cuda.is_available():
@@ -612,15 +476,15 @@ def upscale_video_4k(input_path, output_path):
     thread.daemon = True
     thread.start()
 
-# Initialize directories and try to set up Real-ESRGAN
+# Initialize directories
 ensure_directories()
 
 def force_init_realesrgan():
     """Force Real-ESRGAN initialization with detailed logging"""
-    log_message("🔧 Force initializing Real-ESRGAN...")
+    log_message("🔧 Attempting Real-ESRGAN initialization...")
     
     if not REALESRGAN_AVAILABLE:
-        log_message("❌ Real-ESRGAN package not available")
+        log_message(f"❌ Real-ESRGAN package not available: {REALESRGAN_ERROR}")
         return False
     
     try:
@@ -643,13 +507,15 @@ def force_init_realesrgan():
             
     except Exception as e:
         log_message(f"❌ Real-ESRGAN initialization error: {str(e)}")
-        import traceback
         log_message(f"🔍 Traceback: {traceback.format_exc()}")
         return False
 
 # Try to initialize Real-ESRGAN on startup
 log_message("🚀 Starting Real-ESRGAN initialization...")
-force_init_realesrgan()
+if REALESRGAN_AVAILABLE:
+    force_init_realesrgan()
+else:
+    log_message("⚠️ Real-ESRGAN not available, will use enhanced bicubic fallback")
 
 app = Flask(__name__)
 
@@ -659,7 +525,7 @@ def index():
 
 @app.route('/api/system')
 def api_system():
-    """Get system information"""
+    """Get comprehensive system information"""
     try:
         info = {}
         
@@ -687,6 +553,7 @@ def api_system():
         info["realesrgan_available"] = REALESRGAN_AVAILABLE
         info["realesrgan_initialized"] = app_state["upscaler"] is not None
         info["current_model"] = app_state.get("current_model", "None")
+        info["realesrgan_error"] = REALESRGAN_ERROR
         
         # Check if models exist
         models_status = {}
@@ -711,4 +578,223 @@ def api_system():
             info["storage_outputs"] = f"{output_size / (1024**2):.1f}MB"
             info["upload_files_count"] = len(upload_files)
             info["output_files_count"] = len(output_files)
-        except Exception as e:
+        except Exception as e:
+            info["storage_uploads"] = "Error"
+            info["storage_outputs"] = "Error"
+            info["upload_files_count"] = 0
+            info["output_files_count"] = 0
+        
+        return jsonify({"success": True, "data": info})
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route('/api/upload', methods=['POST'])
+def api_upload():
+    """Upload and process file for 4K upscaling"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({"success": False, "error": "No file provided"})
+        
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({"success": False, "error": "No file selected"})
+        
+        if file and allowed_file(file.filename):
+            file_id = str(uuid.uuid4())
+            filename = secure_filename(file.filename)
+            file_ext = filename.rsplit('.', 1)[1].lower()
+            
+            input_filename = f"{file_id}_input.{file_ext}"
+            input_path = os.path.join(UPLOAD_FOLDER, input_filename)
+            file.save(input_path)
+            
+            output_filename = f"{file_id}_4k.{file_ext}"
+            output_path = os.path.join(OUTPUT_FOLDER, output_filename)
+            
+            if file_ext in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp']:
+                upscale_image_4k(input_path, output_path)
+                media_type = "image"
+            elif file_ext in ['mp4', 'avi', 'mov', 'mkv']:
+                upscale_video_4k(input_path, output_path)
+                media_type = "video"
+            
+            log_message(f"📤 File uploaded: {filename}")
+            log_message(f"🎯 Starting 4K upscaling process...")
+            
+            return jsonify({
+                "success": True, 
+                "file_id": file_id,
+                "filename": filename,
+                "output_filename": output_filename,
+                "media_type": media_type,
+                "message": "Upload successful, processing started"
+            })
+        else:
+            return jsonify({"success": False, "error": "File type not allowed"})
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route('/api/processing-status')
+def api_processing_status():
+    """Get processing status"""
+    return jsonify({
+        "success": True,
+        "processing": app_state["processing_active"],
+        "processed_files": app_state["processed_files"]
+    })
+
+@app.route('/api/download/<filename>')
+def api_download(filename):
+    """Download processed file"""
+    try:
+        file_path = os.path.join(OUTPUT_FOLDER, filename)
+        if os.path.exists(file_path):
+            mimetype = get_file_mimetype(filename)
+            return send_file(
+                file_path,
+                as_attachment=True,
+                download_name=f"4k_upscaled_{filename}",
+                mimetype=mimetype
+            )
+        else:
+            return jsonify({"error": "File not found"}), 404
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/preview/<filename>')
+def api_preview(filename):
+    """Preview processed file"""
+    try:
+        file_path = os.path.join(OUTPUT_FOLDER, filename)
+        if os.path.exists(file_path):
+            mimetype = get_file_mimetype(filename)
+            return send_file(file_path, mimetype=mimetype)
+        else:
+            return jsonify({"error": "File not found"}), 404
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/logs')
+def api_logs():
+    """Get application logs"""
+    return jsonify({
+        "success": True,
+        "logs": app_state["logs"]
+    })
+
+@app.route('/api/clear-logs', methods=['POST'])
+def api_clear_logs():
+    """Clear application logs"""
+    app_state["logs"] = []
+    log_message("🧹 Logs cleared")
+    return jsonify({"success": True, "message": "Logs cleared"})
+
+@app.route('/api/optimize-gpu', methods=['POST'])
+def api_optimize_gpu():
+    """Optimize GPU for processing"""
+    try:
+        success = optimize_gpu()
+        return jsonify({"success": success})
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route('/api/init-realesrgan', methods=['POST'])
+def api_init_realesrgan():
+    """Initialize Real-ESRGAN manually"""
+    try:
+        if not REALESRGAN_AVAILABLE:
+            return jsonify({
+                "success": False, 
+                "error": f"Real-ESRGAN not available: {REALESRGAN_ERROR}"
+            })
+        
+        success = force_init_realesrgan()
+        if success:
+            return jsonify({"success": True, "message": "Real-ESRGAN initialized successfully"})
+        else:
+            return jsonify({"success": False, "error": "Failed to initialize Real-ESRGAN"})
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route('/api/clear-cache', methods=['POST'])
+def api_clear_cache():
+    """Clear cache and processed files"""
+    try:
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        app_state["processed_files"] = []
+        log_message("🧹 Cache and history cleared")
+        
+        return jsonify({"success": True, "message": "Cache cleared"})
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route('/api/test-realesrgan', methods=['POST'])
+def api_test_realesrgan():
+    """Test Real-ESRGAN installation"""
+    try:
+        if not REALESRGAN_AVAILABLE:
+            return jsonify({
+                "success": False,
+                "error": f"Real-ESRGAN not available: {REALESRGAN_ERROR}",
+                "details": {
+                    "import_error": REALESRGAN_ERROR,
+                    "numpy_available": True,
+                    "torch_available": True,
+                    "opencv_available": True
+                }
+            })
+        
+        # Test imports
+        try:
+            from realesrgan import RealESRGANer
+            from basicsr.archs.rrdbnet_arch import RRDBNet
+            import_success = True
+            import_error = None
+        except Exception as e:
+            import_success = False
+            import_error = str(e)
+        
+        return jsonify({
+            "success": import_success,
+            "error": import_error,
+            "details": {
+                "realesrgan_available": REALESRGAN_AVAILABLE,
+                "import_error": import_error,
+                "current_model": app_state.get("current_model"),
+                "upscaler_initialized": app_state["upscaler"] is not None
+            }
+        })
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+if __name__ == '__main__':
+    # Initialize system
+    log_message("🚀 4K Upscaler starting...")
+    
+    try:
+        # Optimize GPU if available
+        if optimize_gpu():
+            log_message("✅ GPU optimization completed")
+        else:
+            log_message("⚠️ Using CPU mode")
+        
+        log_message("✅ 4K Upscaler ready")
+        log_message("📤 Upload images or videos to upscale to 4K resolution")
+        
+        if REALESRGAN_AVAILABLE:
+            log_message("🧠 Real-ESRGAN neural upscaling available")
+        else:
+            log_message("⚠️ Real-ESRGAN not available, using enhanced bicubic fallback")
+        
+    except Exception as e:
+        log_message(f"❌ Initialization error: {str(e)}")
+        log_message("⚠️ Starting in fallback mode...")
+    
+    # Run application
+    try:
+        app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)
+    except Exception as e:
+        log_message(f"❌ Server startup error: {str(e)}")
+        print(f"Critical error: {str(e)}")