Update main.py

main.py

@@ -798,12 +798,23 @@ def approve_project_plan(project_id):
     logger.info(f"[PROJECT APPROVAL] Selected option: {selected_option}")
     
     image_download_start = time.time()
-    response = requests.get(project_data['userImageURL'])
+    try:
+        response = requests.get(project_data['userImageURL'], timeout=30)
+        response.raise_for_status()
+    except requests.RequestException as e:
+        logger.error(f"[PROJECT APPROVAL] ERROR: Image download failed: {e}")
+        return jsonify({'error': 'Failed to download project image'}), 500
+    
     image_download_time = time.time() - image_download_start
     logger.info(f"[PROJECT APPROVAL] Image download completed in {image_download_time:.3f}s, size: {len(response.content)} bytes")
     
     image_processing_start = time.time()
-    pil_image = Image.open(io.BytesIO(response.content)).convert('RGB')
+    try:
+        pil_image = Image.open(io.BytesIO(response.content)).convert('RGB')
+    except Exception as e:
+        logger.error(f"[PROJECT APPROVAL] ERROR: Image processing failed: {e}")
+        return jsonify({'error': 'Failed to process project image'}), 500
+    
     image_processing_time = time.time() - image_processing_start
     logger.info(f"[PROJECT APPROVAL] Image processing completed in {image_processing_time:.3f}s")
 
@@ -860,19 +871,77 @@ def approve_project_plan(project_id):
         parsing_time = time.time() - parsing_start
         logger.info(f"[PROJECT APPROVAL] Response parsing completed in {parsing_time:.3f}s, found {len(inline_images)} images")
 
-        # Text extraction timing
+        # Text extraction timing with robust error handling
         extraction_start = time.time()
-        tools_section = re.search(r"TOOLS AND MATERIALS:\s*(.*?)\s*STEPS:", combined_text, re.DOTALL).group(1).strip()
-        steps_section = re.search(r"STEPS:\s*(.*)", combined_text, re.DOTALL).group(1).strip()
 
-        tools_list = [line.strip("- ").strip() for line in tools_section.split('\n') if line.strip()]
+        # Add debug logging to see what the AI actually returned
+        logger.info(f"[PROJECT APPROVAL] AI Response structure check:")
+        logger.info(f"[PROJECT APPROVAL] Full response length: {len(combined_text)}")
+        logger.info(f"[PROJECT APPROVAL] Contains 'TOOLS AND MATERIALS': {'TOOLS AND MATERIALS' in combined_text.upper()}")
+        logger.info(f"[PROJECT APPROVAL] Contains 'STEPS': {'STEPS' in combined_text.upper()}")
+        logger.info(f"[PROJECT APPROVAL] Response preview: {combined_text[:300]}...")
+
+        # More robust regex patterns with error handling - updated for your production format
+        tools_match = re.search(r"TOOLS AND MATERIALS:\s*(.*?)\s*(?=STEPS\(|STEPS:|$)", combined_text, re.DOTALL | re.IGNORECASE)
+        steps_match = re.search(r"STEPS\([^)]*\):\s*(.*)|STEPS:\s*(.*)", combined_text, re.DOTALL | re.IGNORECASE)
+
+        if not tools_match:
+            logger.error(f"[PROJECT APPROVAL] ERROR: Could not find TOOLS AND MATERIALS section in AI response")
+            logger.error(f"[PROJECT APPROVAL] AI Response full text: {combined_text}")
+            return jsonify({'error': 'AI response format error: Could not parse tools section'}), 500
+
+        if not steps_match:
+            logger.error(f"[PROJECT APPROVAL] ERROR: Could not find STEPS section in AI response")
+            logger.error(f"[PROJECT APPROVAL] AI Response full text: {combined_text}")
+            return jsonify({'error': 'AI response format error: Could not parse steps section'}), 500
+
+        tools_section = tools_match.group(1).strip()
+        steps_section = (steps_match.group(1) or steps_match.group(2)).strip() if steps_match else ""
+
+        # Additional validation
+        if not tools_section:
+            logger.error(f"[PROJECT APPROVAL] ERROR: Empty tools section found")
+            return jsonify({'error': 'AI response format error: Empty tools section'}), 500
+
+        if not steps_section:
+            logger.error(f"[PROJECT APPROVAL] ERROR: Empty steps section found")
+            return jsonify({'error': 'AI response format error: Empty steps section'}), 500
+
+        tools_list = [line.strip("- ").strip() for line in tools_section.split('\n') if line.strip() and not line.strip().startswith('-')]
+        # Also include lines that start with dashes
+        dash_tools = [line.strip("- ").strip() for line in tools_section.split('\n') if line.strip().startswith('-')]
+        tools_list.extend(dash_tools)
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        tools_list = [x for x in tools_list if not (x in seen or seen.add(x))]
+        
         parsed_steps = parse_numbered_steps(steps_section)
+
+        # Validate parsed results
+        if not tools_list:
+            logger.error(f"[PROJECT APPROVAL] ERROR: No tools parsed from response")
+            logger.error(f"[PROJECT APPROVAL] Tools section was: {tools_section}")
+            return jsonify({'error': 'AI response format error: No tools found'}), 500
+
+        if not parsed_steps:
+            logger.error(f"[PROJECT APPROVAL] ERROR: No steps parsed from response")
+            logger.error(f"[PROJECT APPROVAL] Steps section was: {steps_section}")
+            return jsonify({'error': 'AI response format error: No steps found'}), 500
+
         extraction_time = time.time() - extraction_start
         logger.info(f"[PROJECT APPROVAL] Text extraction completed in {extraction_time:.3f}s, tools: {len(tools_list)}, steps: {len(parsed_steps)}")
 
         if len(parsed_steps) != len(inline_images):
             logger.error(f"[PROJECT APPROVAL] ERROR: AI response mismatch - Steps: {len(parsed_steps)}, Images: {len(inline_images)}")
-            return jsonify({'error': 'AI response mismatch: Steps and images do not match.'}), 500
+            # Try to handle the mismatch gracefully
+            min_length = min(len(parsed_steps), len(inline_images))
+            if min_length > 0:
+                logger.info(f"[PROJECT APPROVAL] Attempting to proceed with {min_length} steps/images")
+                parsed_steps = parsed_steps[:min_length]
+                inline_images = inline_images[:min_length]
+            else:
+                return jsonify({'error': 'AI response mismatch: No valid steps and images found.'}), 500
 
         # Step processing timing
         step_processing_start = time.time()
@@ -883,30 +952,42 @@ def approve_project_plan(project_id):
         for i, step_info in enumerate(parsed_steps):
             logger.info(f"[PROJECT APPROVAL] Processing step {i+1}/{len(parsed_steps)}")
             
-            # Image upload timing
-            image_upload_start = time.time()
-            img_byte_arr = io.BytesIO()
-            inline_images[i].save(img_byte_arr, format='JPEG', optimize=True, quality=70)
-            img_path = f"users/{uid}/projects/{project_id}/steps/step_{i+1}_image.jpg"
-            img_url = upload_to_storage(img_byte_arr.getvalue(), img_path, 'image/jpeg')
-            image_upload_time = time.time() - image_upload_start
-            total_upload_time += image_upload_time
-            logger.info(f"[PROJECT APPROVAL] Step {i+1} image upload completed in {image_upload_time:.3f}s")
-
-            # TTS generation timing
-            tts_start = time.time()
-            narration_url = generate_tts_audio_and_upload(step_info['text'], uid, project_id, i + 1)
-            tts_time = time.time() - tts_start
-            total_tts_time += tts_time
-            logger.info(f"[PROJECT APPROVAL] Step {i+1} TTS generation completed in {tts_time:.3f}s")
-            
-            step_info.update({
-                "imageUrl": img_url,
-                "narrationUrl": narration_url,
-                "isDone": False,
-                "notes": ""
-            })
-            final_steps.append(step_info)
+            try:
+                # Image upload timing
+                image_upload_start = time.time()
+                img_byte_arr = io.BytesIO()
+                inline_images[i].save(img_byte_arr, format='JPEG', optimize=True, quality=70)
+                img_path = f"users/{uid}/projects/{project_id}/steps/step_{i+1}_image.jpg"
+                img_url = upload_to_storage(img_byte_arr.getvalue(), img_path, 'image/jpeg')
+                image_upload_time = time.time() - image_upload_start
+                total_upload_time += image_upload_time
+                logger.info(f"[PROJECT APPROVAL] Step {i+1} image upload completed in {image_upload_time:.3f}s")
+
+                # TTS generation timing
+                tts_start = time.time()
+                narration_url = generate_tts_audio_and_upload(step_info['text'], uid, project_id, i + 1)
+                tts_time = time.time() - tts_start
+                total_tts_time += tts_time
+                logger.info(f"[PROJECT APPROVAL] Step {i+1} TTS generation completed in {tts_time:.3f}s")
+                
+                step_info.update({
+                    "imageUrl": img_url,
+                    "narrationUrl": narration_url,
+                    "isDone": False,
+                    "notes": ""
+                })
+                final_steps.append(step_info)
+                
+            except Exception as e:
+                logger.error(f"[PROJECT APPROVAL] ERROR processing step {i+1}: {e}")
+                # Continue with other steps rather than failing entirely
+                step_info.update({
+                    "imageUrl": "",
+                    "narrationUrl": "",
+                    "isDone": False,
+                    "notes": ""
+                })
+                final_steps.append(step_info)
 
         step_processing_time = time.time() - step_processing_start
         logger.info(f"[PROJECT APPROVAL] All steps processing completed in {step_processing_time:.3f}s")
@@ -921,7 +1002,7 @@ def approve_project_plan(project_id):
             "selectedOption": selected_option or ""
         }
         project_ref.update(update_data)
-        logger.info(f"[PROJECT APPROVAL] uodating data in db: {update_data}")
+        logger.info(f"[PROJECT APPROVAL] Updating data in db: {len(update_data)} fields")
         db_update_time = time.time() - db_update_start
         logger.info(f"[PROJECT APPROVAL] Database update completed in {db_update_time:.3f}s")
 
@@ -967,7 +1048,7 @@ def approve_project_plan(project_id):
         logger.error(f"[PROJECT APPROVAL] Project ID: {project_id}, User ID: {uid}")
         import traceback
         logger.error(f"[PROJECT APPROVAL] Full traceback: {traceback.format_exc()}")
-        return jsonify({'error': str(e)}), 500
+        return jsonify({'error': f'Internal server error: {str(e)}'}), 500
 
 @app.route('/api/projects', methods=['GET'])
 def list_projects():