Add route file

App/app.py

@@ -8,10 +8,7 @@ import numpy as np
 import imageio_ffmpeg
 from mtcnn import MTCNN
 from ultralytics import YOLO
-from flask import Flask, request, render_template, send_from_directory, jsonify
-from werkzeug.utils import secure_filename
-import uuid
-import threading
+from flask import Flask
 from tensorflow.keras.models import load_model
 from tensorflow.keras.applications.efficientnet import preprocess_input
 import keras.src.layers.normalization.batch_normalization as _bn_module
@@ -296,107 +293,8 @@ def cleanup_old_uploads(exclude=None):
                 pass
 
 
-@app.route('/', methods=['GET'])
-def index():
-    return render_template('index.html')
-
-
-@app.route('/uploads/<filename>')
-def uploaded_video(filename):
-    return send_from_directory(app.config['UPLOAD_FOLDER'], filename, mimetype='video/mp4')
-
-
-def process_video_job(job_id, filepath, unique_name):
-    """Background worker: extract faces, predict, create processed video."""
-    try:
-        logger.info('[Job %s] Starting face detection', job_id)
-        jobs[job_id]['status'] = 'detecting'
-
-        faces = extract_faces_from_video(filepath)
-        avg_score, num_faces, faces_detail = predict_deepfake(faces)
-
-        if avg_score is None:
-            logger.warning('[Job %s] No faces detected', job_id)
-            jobs[job_id].update({
-                'status': 'done',
-                'error': 'No faces detected in the video.',
-                'video_url': f'/uploads/{unique_name}',
-            })
-            return
-
-        is_real = avg_score > 0.5
-        label = 'REAL' if is_real else 'FAKE'
-        confidence = avg_score if is_real else (1 - avg_score)
-
-        # Publish detection results immediately
-        logger.info('[Job %s] Detection done — result: %s, confidence: %.2f%%, faces: %d',
-                    job_id, label, confidence * 100, num_faces)
-        jobs[job_id].update({
-            'status': 'processing_video',
-            'result': label,
-            'confidence': round(confidence * 100, 2),
-            'score': round(avg_score, 4),
-            'num_faces': num_faces,
-            'faces_detail': faces_detail,
-            'video_url': f'/uploads/{unique_name}',
-        })
-
-        # Now generate processed video (results already visible to client)
-        logger.info('[Job %s] Starting video processing', job_id)
-        processed_name = f"processed_{unique_name}"
-        processed_path = os.path.join(app.config['UPLOAD_FOLDER'], processed_name)
-        create_processed_video(filepath, processed_path)
-
-        logger.info('[Job %s] Video processing done', job_id)
-        jobs[job_id].update({
-            'status': 'done',
-            'processed_url': f'/uploads/{processed_name}',
-        })
-    except Exception as e:
-        logger.error('[Job %s] Error: %s', job_id, e)
-        jobs[job_id].update({'status': 'done', 'error': str(e)})
-
-
-@app.route('/predict', methods=['POST'])
-def predict():
-    if 'video' not in request.files:
-        return jsonify({'error': 'No video file uploaded.'}), 400
-
-    file = request.files['video']
-    if file.filename == '':
-        return jsonify({'error': 'No file selected.'}), 400
-
-    if not allowed_file(file.filename):
-        return jsonify({'error': 'Invalid file type. Allowed: mp4, avi, mov, mkv, wmv'}), 400
-
-    cleanup_old_uploads()
-
-    ext = secure_filename(file.filename).rsplit('.', 1)[1].lower()
-    unique_name = f"{uuid.uuid4().hex}.{ext}"
-    filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_name)
-    file.save(filepath)
-    logger.info('Video uploaded: %s (%s)', file.filename, unique_name)
-
-    # Re-encode upload to H.264 so browser can play it
-    logger.info('Re-encoding uploaded video to H.264')
-    reencode_to_h264(filepath)
-
-    job_id = uuid.uuid4().hex
-    logger.info('Created job %s for %s', job_id, unique_name)
-    jobs[job_id] = {'status': 'uploading', 'video_url': f'/uploads/{unique_name}'}
-
-    thread = threading.Thread(target=process_video_job, args=(job_id, filepath, unique_name))
-    thread.start()
-
-    return jsonify({'job_id': job_id, 'video_url': f'/uploads/{unique_name}'})
-
-
-@app.route('/status/<job_id>')
-def job_status(job_id):
-    job = jobs.get(job_id)
-    if not job:
-        return jsonify({'error': 'Job not found'}), 404
-    return jsonify(job)
+from route import routes
+app.register_blueprint(routes)
 
 
 if __name__ == '__main__':

App/route.py

@@ -0,0 +1,128 @@
+import os
+import logging
+import uuid
+import threading
+from flask import Blueprint, request, render_template, send_from_directory, jsonify
+from werkzeug.utils import secure_filename
+
+logger = logging.getLogger(__name__)
+
+routes = Blueprint('routes', __name__)
+
+
+def _get_app_deps():
+    """Import app-level objects to avoid circular imports."""
+    from app import (
+        app, jobs, allowed_file, cleanup_old_uploads,
+        extract_faces_from_video, predict_deepfake,
+        create_processed_video, reencode_to_h264
+    )
+    return app, jobs, allowed_file, cleanup_old_uploads, \
+        extract_faces_from_video, predict_deepfake, \
+        create_processed_video, reencode_to_h264
+
+
+@routes.route('/', methods=['GET'])
+def index():
+    return render_template('index.html')
+
+
+@routes.route('/uploads/<filename>')
+def uploaded_video(filename):
+    from app import app
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename, mimetype='video/mp4')
+
+
+def process_video_job(job_id, filepath, unique_name):
+    """Background worker: extract faces, predict, create processed video."""
+    app, jobs, _, _, extract_faces_from_video, predict_deepfake, \
+        create_processed_video, _ = _get_app_deps()
+    try:
+        logger.info('[Job %s] Starting face detection', job_id)
+        jobs[job_id]['status'] = 'detecting'
+
+        faces = extract_faces_from_video(filepath)
+        avg_score, num_faces, faces_detail = predict_deepfake(faces)
+
+        if avg_score is None:
+            logger.warning('[Job %s] No faces detected', job_id)
+            jobs[job_id].update({
+                'status': 'done',
+                'error': 'No faces detected in the video.',
+                'video_url': f'/uploads/{unique_name}',
+            })
+            return
+
+        is_real = avg_score > 0.5
+        label = 'REAL' if is_real else 'FAKE'
+        confidence = avg_score if is_real else (1 - avg_score)
+
+        logger.info('[Job %s] Detection done — result: %s, confidence: %.2f%%, faces: %d',
+                    job_id, label, confidence * 100, num_faces)
+        jobs[job_id].update({
+            'status': 'processing_video',
+            'result': label,
+            'confidence': round(confidence * 100, 2),
+            'score': round(avg_score, 4),
+            'num_faces': num_faces,
+            'faces_detail': faces_detail,
+            'video_url': f'/uploads/{unique_name}',
+        })
+
+        logger.info('[Job %s] Starting video processing', job_id)
+        processed_name = f"processed_{unique_name}"
+        processed_path = os.path.join(app.config['UPLOAD_FOLDER'], processed_name)
+        create_processed_video(filepath, processed_path)
+
+        logger.info('[Job %s] Video processing done', job_id)
+        jobs[job_id].update({
+            'status': 'done',
+            'processed_url': f'/uploads/{processed_name}',
+        })
+    except Exception as e:
+        logger.error('[Job %s] Error: %s', job_id, e)
+        jobs[job_id].update({'status': 'done', 'error': str(e)})
+
+
+@routes.route('/predict', methods=['POST'])
+def predict():
+    app, jobs, allowed_file, cleanup_old_uploads, _, _, _, reencode_to_h264 = _get_app_deps()
+
+    if 'video' not in request.files:
+        return jsonify({'error': 'No video file uploaded.'}), 400
+
+    file = request.files['video']
+    if file.filename == '':
+        return jsonify({'error': 'No file selected.'}), 400
+
+    if not allowed_file(file.filename):
+        return jsonify({'error': 'Invalid file type. Allowed: mp4, avi, mov, mkv, wmv'}), 400
+
+    cleanup_old_uploads()
+
+    ext = secure_filename(file.filename).rsplit('.', 1)[1].lower()
+    unique_name = f"{uuid.uuid4().hex}.{ext}"
+    filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_name)
+    file.save(filepath)
+    logger.info('Video uploaded: %s (%s)', file.filename, unique_name)
+
+    logger.info('Re-encoding uploaded video to H.264')
+    reencode_to_h264(filepath)
+
+    job_id = uuid.uuid4().hex
+    logger.info('Created job %s for %s', job_id, unique_name)
+    jobs[job_id] = {'status': 'uploading', 'video_url': f'/uploads/{unique_name}'}
+
+    thread = threading.Thread(target=process_video_job, args=(job_id, filepath, unique_name))
+    thread.start()
+
+    return jsonify({'job_id': job_id, 'video_url': f'/uploads/{unique_name}'})
+
+
+@routes.route('/status/<job_id>')
+def job_status(job_id):
+    from app import jobs
+    job = jobs.get(job_id)
+    if not job:
+        return jsonify({'error': 'Job not found'}), 404
+    return jsonify(job)