Update app.py

app.py

@@ -27,34 +27,45 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
+def timing_decorator(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        logging.info(f'{func.__name__} took {end-start:.2f} seconds to execute')
+        return result
+    return wrapper
+
 class FaceAnalysisApp:
     def __init__(self):
         self.app = Flask(__name__, static_folder='static')
         self.setup_app()
-        
+        self.results_cache = {}
+        self.task_queue = queue.Queue()
+        self.setup_routes()
+        self.start_worker_thread()
+
     def setup_app(self):
+        """Configure l'application Flask"""
         # Configuration de base
-        self.app.config['UPLOAD_FOLDER'] = 'static/uploads'
-        self.app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
-        self.app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'gif'}
-        self.app.config['SECRET_KEY'] = os.urandom(24)
+        self.app.config.update(
+            UPLOAD_FOLDER='static/uploads',
+            MAX_CONTENT_LENGTH=16 * 1024 * 1024,
+            ALLOWED_EXTENSIONS={'png', 'jpg', 'jpeg', 'gif'},
+            SECRET_KEY=os.urandom(24)
+        )
         
-        # Initialisation des composants
+        # Initialisation CORS et Limiter
         CORS(self.app)
         self.limiter = Limiter(
             self.app,
             key_func=get_remote_address,
             default_limits=["200 per day", "50 per hour"]
         )
-        
-        # File d'attente pour le traitement asynchrone
-        self.task_queue = queue.Queue()
-        self.start_worker_thread()
-        
-        # Cache pour les résultats
-        self.results_cache = {}
-        
+
     def start_worker_thread(self):
+        """Démarre le thread de traitement en arrière-plan"""
         def worker():
             while True:
                 task = self.task_queue.get()
@@ -64,21 +75,12 @@ class FaceAnalysisApp:
                     task()
                 except Exception as e:
                     logging.error(f"Error in worker thread: {str(e)}")
-                self.task_queue.task_done()
-                
+                finally:
+                    self.task_queue.task_done()
+
         self.worker_thread = threading.Thread(target=worker, daemon=True)
         self.worker_thread.start()
 
-    def timing_decorator(self, f):
-        @wraps(f)
-        def wrap(*args, **kwargs):
-            start = time.time()
-            result = f(*args, **kwargs)
-            end = time.time()
-            logging.info(f'{f.__name__} took {end-start:.2f} seconds to execute')
-            return result
-        return wrap
-
     def validate_image(self, image_stream):
         """Valide et optimise l'image"""
         try:
@@ -103,7 +105,7 @@ class FaceAnalysisApp:
             raise ValueError("Invalid image format")
 
     def process_face_detection(self, image_path):
-        """Détection de visage avec mise en cache"""
+        """Détecte les visages avec mise en cache"""
         image_hash = hashlib.md5(open(image_path, 'rb').read()).hexdigest()
         
         if image_hash in self.results_cache:
@@ -123,14 +125,15 @@ class FaceAnalysisApp:
 
     @timing_decorator
     def verify_faces(self, image1_path, image2_path):
-        """Comparaison des visages avec vérification approfondie"""
+        """Compare deux visages"""
         try:
-            # Vérification initiale de la présence de visages
+            # Vérification des images
             face1 = cv2.imread(image1_path)
             face2 = cv2.imread(image2_path)
             if face1 is None or face2 is None:
                 raise ValueError("Unable to read one or both images")
 
+            # Comparaison des visages
             result = DeepFace.verify(
                 img1_path=image1_path,
                 img2_path=image2_path,
@@ -139,9 +142,11 @@ class FaceAnalysisApp:
             )
             
             # Enrichissement des résultats
-            result['timestamp'] = datetime.now().isoformat()
-            result['confidence_score'] = 1 - result.get('distance', 0)
-            result['processing_time'] = time.time()
+            result.update({
+                'timestamp': datetime.now().isoformat(),
+                'confidence_score': 1 - result.get('distance', 0),
+                'processing_time': time.time()
+            })
             
             return result
         except Exception as e:
@@ -149,6 +154,8 @@ class FaceAnalysisApp:
             raise
 
     def setup_routes(self):
+        """Configure les routes de l'application"""
+        
         @self.app.route('/')
         def index():
             return render_template('index.html')
@@ -157,6 +164,7 @@ class FaceAnalysisApp:
         @self.limiter.limit("10 per minute")
         def verify_faces_endpoint():
             try:
+                # Vérification des fichiers
                 if 'image1' not in request.files or 'image2' not in request.files:
                     return jsonify({'error': 'Two images are required'}), 400
 
@@ -170,35 +178,33 @@ class FaceAnalysisApp:
                 except ValueError as e:
                     return jsonify({'error': str(e)}), 400
 
-                # Création des fichiers temporaires
+                # Traitement des images
                 with tempfile.TemporaryDirectory() as temp_dir:
-                    image1_path = os.path.join(temp_dir, secure_filename(image1.filename))
-                    image2_path = os.path.join(temp_dir, secure_filename(image2.filename))
-                    
-                    # Sauvegarde des images optimisées
-                    with open(image1_path, 'wb') as f:
-                        f.write(image1_stream.getvalue())
-                    with open(image2_path, 'wb') as f:
-                        f.write(image2_stream.getvalue())
-                    
-                    # Analyse des visages
-                    result = self.verify_faces(image1_path, image2_path)
-                    
-                    # Sauvegarde permanente si nécessaire
+                    # Sauvegarde temporaire
+                    paths = []
+                    for img, stream in [(image1, image1_stream), (image2, image2_stream)]:
+                        path = os.path.join(temp_dir, secure_filename(img.filename))
+                        with open(path, 'wb') as f:
+                            f.write(stream.getvalue())
+                        paths.append(path)
+
+                    # Vérification des visages
+                    result = self.verify_faces(paths[0], paths[1])
+
+                    # Sauvegarde des résultats positifs
                     if result['verified']:
                         permanent_dir = os.path.join(self.app.static_folder, 'verified_faces')
                         os.makedirs(permanent_dir, exist_ok=True)
                         
-                        # Génération de noms uniques
-                        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-                        image1_name = f"face1_{timestamp}_{uuid.uuid4().hex[:8]}.jpg"
-                        image2_name = f"face2_{timestamp}_{uuid.uuid4().hex[:8]}.jpg"
-                        
-                        shutil.copy2(image1_path, os.path.join(permanent_dir, image1_name))
-                        shutil.copy2(image2_path, os.path.join(permanent_dir, image2_name))
+                        saved_paths = []
+                        for i, path in enumerate(paths, 1):
+                            name = f"face{i}_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}.jpg"
+                            dest = os.path.join(permanent_dir, name)
+                            shutil.copy2(path, dest)
+                            saved_paths.append(f'/static/verified_faces/{name}')
                         
-                        result['image1_url'] = f'/static/verified_faces/{image1_name}'
-                        result['image2_url'] = f'/static/verified_faces/{image2_name}'
+                        result['image1_url'] = saved_paths[0]
+                        result['image2_url'] = saved_paths[1]
 
                 return jsonify(result)
 
@@ -221,7 +227,7 @@ class FaceAnalysisApp:
                 except ValueError as e:
                     return jsonify({'error': str(e)}), 400
 
-                # Traitement asynchrone
+                # File d'attente pour les résultats
                 result_queue = queue.Queue()
                 
                 def process_task():
@@ -238,9 +244,10 @@ class FaceAnalysisApp:
                         except:
                             pass
 
+                # Ajout de la tâche à la file d'attente
                 self.task_queue.put(process_task)
                 
-                # Attente du résultat avec timeout
+                # Attente du résultat
                 try:
                     status, result = result_queue.get(timeout=30)
                     if status == 'error':
@@ -262,7 +269,7 @@ class FaceAnalysisApp:
             return jsonify({'error': 'Rate limit exceeded'}), 429
 
     def run(self, host='0.0.0.0', port=5000, debug=False):
-        self.setup_routes()
+        """Démarre l'application Flask"""
         self.app.run(host=host, port=port, debug=debug)
 
 if __name__ == '__main__':