Update app.py

app.py

@@ -14,9 +14,9 @@ import logging
 from flask_cors import CORS
 
 # Set up logging
-logging.basicConfig(level=logging.DEBUG, 
-                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-                   handlers=[logging.StreamHandler()])
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    handlers=[logging.StreamHandler()])
 logger = logging.getLogger(__name__)
 
 # Import attempt with error handling
@@ -41,7 +41,7 @@ try:
     logger.info("Successfully initialized workout logger")
 except ImportError:
     logger.warning("WorkoutLogger import failed, creating dummy class")
-    
+
     class DummyWorkoutLogger:
         def __init__(self):
             pass
@@ -55,7 +55,7 @@ except ImportError:
             return {}
         def get_user_stats(self, *args, **kwargs):
             return {'total_workouts': 0, 'total_exercises': 0, 'streak_days': 0}
-    
+
     workout_logger = DummyWorkoutLogger()
 
 logger.info("Setting up Flask application")
@@ -67,7 +67,7 @@ socketio = SocketIO(app, cors_allowed_origins="*")
 pose_estimator_api = None
 active_exercise_sessions = {}
 # Max number of concurrent sessions to avoid memory issues
-MAX_SESSIONS = 100 
+MAX_SESSIONS = 100
 
 def get_pose_estimator_api_instance():
     global pose_estimator_api
@@ -104,45 +104,45 @@ def release_camera():
 def generate_frames():
     global output_frame, lock, exercise_running, current_exercise, current_exercise_data
     global exercise_counter, exercise_goal, sets_completed, sets_goal
-    
+
     pose_estimator = PoseEstimator()
-    
+
     while True:
         if camera is None:
             continue
-            
+
         success, frame = camera.read()
         if not success:
             continue
-        
+
         # Only process frames if an exercise is running
         if exercise_running and current_exercise:
             # Process with pose estimation
             results = pose_estimator.estimate_pose(frame, current_exercise_data['type'])
-            
+
             if results.pose_landmarks:
                 # Track exercise based on type
                 if current_exercise_data['type'] == "squat":
                     counter, angle, stage = current_exercise.track_squat(results.pose_landmarks.landmark, frame)
                     layout_indicators(frame, current_exercise_data['type'], (counter, angle, stage))
                     exercise_counter = counter
-                    
+
                 elif current_exercise_data['type'] == "push_up":
                     counter, angle, stage = current_exercise.track_push_up(results.pose_landmarks.landmark, frame)
                     layout_indicators(frame, current_exercise_data['type'], (counter, angle, stage))
                     exercise_counter = counter
-                    
+
                 elif current_exercise_data['type'] == "hammer_curl":
                     (counter_right, angle_right, counter_left, angle_left,
-                     warning_message_right, warning_message_left, progress_right, 
+                     warning_message_right, warning_message_left, progress_right,
                      progress_left, stage_right, stage_left) = current_exercise.track_hammer_curl(
                         results.pose_landmarks.landmark, frame)
-                    layout_indicators(frame, current_exercise_data['type'], 
+                    layout_indicators(frame, current_exercise_data['type'],
                                      (counter_right, angle_right, counter_left, angle_left,
-                                      warning_message_right, warning_message_left, 
+                                      warning_message_right, warning_message_left,
                                       progress_right, progress_left, stage_right, stage_left))
                     exercise_counter = max(counter_right, counter_left)
-                
+
                 # Display exercise information
                 exercise_info = get_exercise_info(current_exercise_data['type'])
                 draw_text_with_background(frame, f"Exercise: {exercise_info.get('name', 'N/A')}", (40, 50),
@@ -153,7 +153,7 @@ def generate_frames():
                                          cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255), (118, 29, 14), 1)
                 draw_text_with_background(frame, f"Current Set: {sets_completed + 1}", (40, 140),
                                          cv2.FONT_HERSHEY_DUPLEX, 0.7, (255, 255, 255), (118, 29, 14), 1)
-                
+
                 # Check if rep goal is reached for current set
                 if exercise_counter >= exercise_goal:
                     sets_completed += 1
@@ -164,14 +164,14 @@ def generate_frames():
                     elif current_exercise_data['type'] == "hammer_curl":
                         current_exercise.counter_right = 0
                         current_exercise.counter_left = 0
-                    
+
                     # Check if all sets are completed
                     if sets_completed >= sets_goal:
                         exercise_running = False
                         draw_text_with_background(frame, "WORKOUT COMPLETE!", (frame.shape[1]//2 - 150, frame.shape[0]//2),
                                                 cv2.FONT_HERSHEY_DUPLEX, 1.2, (255, 255, 255), (0, 200, 0), 2)
                     else:
-                        draw_text_with_background(frame, f"SET {sets_completed} COMPLETE! Rest for 30 sec", 
+                        draw_text_with_background(frame, f"SET {sets_completed} COMPLETE! Rest for 30 sec",
                                                 (frame.shape[1]//2 - 200, frame.shape[0]//2),
                                                 cv2.FONT_HERSHEY_DUPLEX, 1.0, (255, 255, 255), (0, 0, 200), 2)
                         # We could add rest timer functionality here
@@ -179,11 +179,11 @@ def generate_frames():
             # Display welcome message if no exercise is running
             cv2.putText(frame, "Select an exercise to begin", (frame.shape[1]//2 - 150, frame.shape[0]//2),
                        cv2.FONT_HERSHEY_DUPLEX, 0.8, (255, 255, 255), 1)
-                
+
         # Encode the frame in JPEG format
         with lock:
             output_frame = frame.copy()
-            
+
         # Yield the frame in byte format
         ret, buffer = cv2.imencode('.jpg', output_frame)
         frame = buffer.tobytes()
@@ -210,7 +210,7 @@ def dashboard():
         weekly_stats = workout_logger.get_weekly_stats()
         exercise_distribution = workout_logger.get_exercise_distribution()
         user_stats = workout_logger.get_user_stats()
-        
+
         # Format workouts for display
         formatted_workouts = []
         for workout in recent_workouts:
@@ -221,10 +221,10 @@ def dashboard():
                 'reps': workout['reps'],
                 'duration': f"{workout['duration_seconds'] // 60}:{workout['duration_seconds'] % 60:02d}"
             })
-        
+
         # Calculate total workouts this week
         weekly_workout_count = sum(day['workout_count'] for day in weekly_stats.values())
-        
+
         return render_template('dashboard.html',
                               recent_workouts=formatted_workouts,
                               weekly_workouts=weekly_workout_count,
@@ -248,20 +248,20 @@ def start_exercise():
     global exercise_running, current_exercise, current_exercise_data
     global exercise_counter, exercise_goal, sets_completed, sets_goal
     global workout_start_time
-    
+
     data = request.json
     exercise_type = data.get('exercise_type')
     sets_goal = int(data.get('sets', 3))
     exercise_goal = int(data.get('reps', 10))
-    
+
     # Initialize camera if not already done
     initialize_camera()
-    
+
     # Reset counters
     exercise_counter = 0
     sets_completed = 0
     workout_start_time = time.time()
-    
+
     # Initialize the appropriate exercise class
     if exercise_type == "squat":
         current_exercise = Squat()
@@ -271,17 +271,17 @@ def start_exercise():
         current_exercise = HammerCurl()
     else:
         return jsonify({'success': False, 'error': 'Invalid exercise type'})
-    
+
     # Store exercise data
     current_exercise_data = {
         'type': exercise_type,
         'sets': sets_goal,
         'reps': exercise_goal
     }
-    
+
     # Start the exercise
     exercise_running = True
-    
+
     return jsonify({'success': True})
 
 @app.route('/stop_exercise', methods=['POST'])
@@ -289,11 +289,11 @@ def stop_exercise():
     """Stop the current exercise and log the workout"""
     global exercise_running, current_exercise_data, workout_start_time
     global exercise_counter, exercise_goal, sets_completed, sets_goal
-    
+
     if exercise_running and current_exercise_data:
         # Calculate duration
         duration = int(time.time() - workout_start_time) if workout_start_time else 0
-        
+
         # Log the workout
         workout_logger.log_workout(
             exercise_type=current_exercise_data['type'],
@@ -309,7 +309,7 @@ def stop_exercise():
 def get_status():
     """Return current exercise status"""
     global exercise_counter, sets_completed, exercise_goal, sets_goal, exercise_running
-    
+
     return jsonify({
         'exercise_running': exercise_running,
         'current_reps': exercise_counter,
@@ -325,7 +325,7 @@ def profile():
 
 @app.route('/healthz')
 def health_check():
-    logger.info("Health check endpoint called successfully.")
+    logger.info("HEALTH CHECK ENDPOINT CALLED AND RESPONDING OK")
     return "OK", 200
 
 @app.route('/api/analyze_frame', methods=['POST'])
@@ -336,7 +336,7 @@ def analyze_frame():
         if not data or 'image' not in data:
             logger.warning("API /api/analyze_frame: No image provided or invalid JSON.")
             return jsonify({'error': 'No image provided in JSON payload (expected base64 string under "image" key)'}), 400
-        
+
         # Use 'squat' as a default if not provided. This primarily affects server-side drawing, not the landmarks themselves.
         exercise_type_for_api = data.get('exercise_type', 'squat')
         if exercise_type_for_api not in ["squat", "push_up", "hammer_curl"]: # Validate against known types if necessary
@@ -344,7 +344,7 @@ def analyze_frame():
             exercise_type_for_api = "squat"
 
         image_data = data['image']
-        
+
         # Add padding if missing for base64 decoding
         missing_padding = len(image_data) % 4
         if missing_padding:
@@ -361,10 +361,10 @@ def analyze_frame():
             return jsonify({'error': f'Invalid base64 image data: {str(e)}'}), 400
 
         estimator = get_pose_estimator_api_instance()
-        
+
         # Process with pose estimation
-        results = estimator.estimate_pose(frame, exercise_type_for_api) 
-        
+        results = estimator.estimate_pose(frame, exercise_type_for_api)
+
         landmarks_list = []
         if results.pose_landmarks:
             for i, landmark in enumerate(results.pose_landmarks.landmark):
@@ -406,7 +406,7 @@ def track_exercise_stream():
 
         if not isinstance(frame_width, int) or not isinstance(frame_height, int) or frame_width <= 0 or frame_height <= 0:
             return jsonify({'error': 'Invalid frame_width or frame_height'}), 400
-        
+
         # Manage session limit
         if len(active_exercise_sessions) >= MAX_SESSIONS and session_id not in active_exercise_sessions:
             logger.warning(f"Max sessions ({MAX_SESSIONS}) reached. Rejecting new session {session_id}.")
@@ -426,7 +426,7 @@ def track_exercise_stream():
             else:
                 logger.warning(f"Invalid exercise type: {exercise_type} for session {session_id}")
                 return jsonify({'error': 'Invalid exercise_type'}), 400
-        
+
         exercise_session = active_exercise_sessions[session_id]
 
         # Decode image (similar to /api/analyze_frame)
@@ -445,18 +445,18 @@ def track_exercise_stream():
         pose_estimator = get_pose_estimator_api_instance() # Reusing the existing estimator instance getter
         # The 'squat' here is just a default for PoseEstimator's internal drawing logic, which we don't use for API response.
         # The actual exercise type for tracking is handled by `exercise_session` object.
-        results = pose_estimator.estimate_pose(frame_for_estimation, 'squat') 
+        results = pose_estimator.estimate_pose(frame_for_estimation, 'squat')
 
         if not results.pose_landmarks:
             logger.info(f"Session {session_id}: No landmarks detected.")
             # Return current state even if no new landmarks, or specific message
             return jsonify({
-                'success': True, 
+                'success': True,
                 'landmarks_detected': False,
                 'message': 'No landmarks detected in this frame.',
                 # Optionally, could return last known state from exercise_session if needed
             })
-        
+
         exercise_data = None
         if exercise_type == 'squat':
             exercise_data = exercise_session.track_squat(results.pose_landmarks.landmark, frame_width, frame_height)
@@ -464,7 +464,7 @@ def track_exercise_stream():
             exercise_data = exercise_session.track_push_up(results.pose_landmarks.landmark, frame_width, frame_height)
         elif exercise_type == 'hammer_curl':
             exercise_data = exercise_session.track_hammer_curl(results.pose_landmarks.landmark, frame_width, frame_height)
-        
+
         if exercise_data:
             logger.debug(f"Session {session_id}: Exercise data: {exercise_data}")
             return jsonify({'success': True, 'landmarks_detected': True, 'data': exercise_data})
@@ -486,7 +486,7 @@ def end_exercise_session():
         data = request.json
         if not data:
             return jsonify({'error': 'No JSON data provided'}), 400
-        
+
         session_id = data.get('session_id')
         if not session_id:
             return jsonify({'error': 'Missing session_id'}), 400
@@ -547,7 +547,7 @@ def handle_start_exercise_session(data):
         logger.warning(f"Invalid exercise type: {exercise_type} for session {request.sid}")
         socketio.emit('session_error', {'error': 'Invalid exercise_type'}, room=request.sid)
         return
-    
+
     logger.info(f"Successfully created exercise session for {request.sid}, type: {exercise_type}")
     socketio.emit('session_started', {'session_id': request.sid, 'exercise_type': exercise_type}, room=request.sid)
 
@@ -579,43 +579,42 @@ def handle_process_frame(data):
         return
 
     try:
-        missing_padding = len(image_data_base64) % 4
-        if missing_padding:
-            image_data_base64 += '=' * (4 - missing_padding)
-        
-        image_bytes = base64.b64decode(image_data_base64)
-        pil_image = Image.open(io.BytesIO(image_bytes))
-        frame_for_estimation = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
-    except Exception as e:
-        logger.error(f"Error decoding base64 image for {request.sid}: {e}")
-        socketio.emit('frame_error', {'error': f'Invalid base64 image data: {str(e)}'}, room=request.sid)
-        return
+        # This try-except block is for image decoding
+        try:
+            missing_padding = len(image_data_base64) % 4
+            if missing_padding:
+                image_data_base64 += '=' * (4 - missing_padding)
+            
+            image_bytes = base64.b64decode(image_data_base64)
+            pil_image = Image.open(io.BytesIO(image_bytes))
+            frame_for_estimation = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+        except Exception as e:
+            logger.error(f"Error decoding base64 image for {request.sid}: {e}")
+            socketio.emit('frame_error', {'error': f'Invalid base64 image data: {str(e)}'}, room=request.sid)
+            return # Important to return here if decoding fails
 
-    pose_estimator = get_pose_estimator_api_instance()
-    # The 'squat' parameter to estimate_pose is a default for drawing, actual logic is in exercise_session
-    results = pose_estimator.estimate_pose(frame_for_estimation, session_exercise_type) 
-
-    exercise_data_result = None
-    if results.pose_landmarks:
-        if session_exercise_type == 'squat':
-            exercise_data_result = exercise_session.track_squat(results.pose_landmarks.landmark, frame_width, frame_height)
-        elif session_exercise_type == 'push_up':
-            exercise_data_result = exercise_session.track_push_up(results.pose_landmarks.landmark, frame_width, frame_height)
-        elif session_exercise_type == 'hammer_curl':
-            exercise_data_result = exercise_session.track_hammer_curl(results.pose_landmarks.landmark, frame_width, frame_height)
-        
-        if exercise_data_result:
-            # logger.debug(f"Exercise data for {request.sid}: {exercise_data_result}")
-            socketio.emit('exercise_update', {'success': True, 'landmarks_detected': True, 'data': exercise_data_result}, room=request.sid)
+        # This is the main processing logic that should be wrapped in the outer try-except
+        pose_estimator = get_pose_estimator_api_instance()
+        results = pose_estimator.estimate_pose(frame_for_estimation, session_exercise_type) 
+
+        exercise_data_result = None
+        if results.pose_landmarks:
+            if session_exercise_type == 'squat':
+                exercise_data_result = exercise_session.track_squat(results.pose_landmarks.landmark, frame_width, frame_height)
+            elif session_exercise_type == 'push_up':
+                exercise_data_result = exercise_session.track_push_up(results.pose_landmarks.landmark, frame_width, frame_height)
+            elif session_exercise_type == 'hammer_curl':
+                exercise_data_result = exercise_session.track_hammer_curl(results.pose_landmarks.landmark, frame_width, frame_height)
+            
+            if exercise_data_result:
+                socketio.emit('exercise_update', {'success': True, 'landmarks_detected': True, 'data': exercise_data_result}, room=request.sid)
+            else:
+                logger.error(f"Could not get exercise_data for {request.sid}, type {session_exercise_type}, despite landmarks.")
+                socketio.emit('exercise_update', {'success': False, 'landmarks_detected': True, 'message': 'Error processing landmarks.'}, room=request.sid)
         else:
-            # This case should ideally not be reached if landmarks are detected and exercise type is valid
-            logger.error(f"Could not get exercise data for {request.sid}, type {session_exercise_type}, despite landmarks.")
-            socketio.emit('exercise_update', {'success': False, 'landmarks_detected': True, 'message': 'Error processing landmarks.'}, room=request.sid)
-    else:
-        # logger.info(f"No landmarks detected for {request.sid}.")
-        socketio.emit('exercise_update', {'success': True, 'landmarks_detected': False, 'message': 'No landmarks detected.'}, room=request.sid)
+            socketio.emit('exercise_update', {'success': True, 'landmarks_detected': False, 'message': 'No landmarks detected.'}, room=request.sid)
 
-    except Exception as e:
+    except Exception as e: # This is the general exception handler for the processing logic
         logger.error(f"Error processing frame for {request.sid}: {e}")
         traceback.print_exc()
         socketio.emit('frame_error', {'error': f'Internal server error during frame processing: {str(e)}'}, room=request.sid)
@@ -629,4 +628,4 @@ if __name__ == '__main__':
         socketio.run(app, debug=True, host='0.0.0.0', port=5000)
     except Exception as e:
         logger.error(f"Failed to start application: {e}")
-        traceback.print_exc()
+        traceback.print_exc()