Update main.py

main.py

@@ -575,70 +575,141 @@ def approve_project_plan(project_id):
         return jsonify({'error': 'Project not found or access denied'}), 404
 
     selected_option = request.json.get('selectedOption')
-    response = requests.get(project_data['userImageURL'])
-    pil_image = Image.open(io.BytesIO(response.content))
+    
+    # Optimized image download with timeout and session reuse
+    try:
+        session = requests.Session()
+        session.headers.update({'User-Agent': 'Mozilla/5.0'})
+        
+        with session.get(project_data['userImageURL'], timeout=15, stream=True) as response:
+            response.raise_for_status()
+            image_data = io.BytesIO()
+            for chunk in response.iter_content(chunk_size=8192):
+                image_data.write(chunk)
+            image_data.seek(0)
+            pil_image = Image.open(image_data)
+            
+    except Exception as e:
+        return jsonify({'error': f'Failed to download image: {str(e)}'}), 400
 
     context = f"The user chose the upcycling project: '{selected_option}'." if selected_option else f"The user has approved the plan for '{project_data['projectTitle']}'."
 
-    detailed_prompt = f"""
-    You are a DIY expert. The user wants to proceed with the project titled "{project_data['projectTitle']}".
-    {context}
-    Provide a detailed guide. For each step, you MUST provide a simple, clear illustrative image.
-    Format your response EXACTLY like this:
+    # Streamlined prompt
+    detailed_prompt = f"""You are a DIY expert. The user wants to proceed with the project titled "{project_data['projectTitle']}".
+{context}
+Provide a detailed guide. For each step, you MUST provide a simple, clear illustrative image.
+Format your response EXACTLY like this:
+TOOLS AND MATERIALS:
+- Tool A
+- Material B
+STEPS(Maximum 7 steps):
+1. First step instructions.
+2. Second step instructions..."""
 
-    TOOLS AND MATERIALS:
-    - Tool A
-    - Material B
-
-    STEPS(Maximum 7 steps):
-    1. First step instructions.
-    2. Second step instructions...
-    """
     try:
-        chat = client.chats.create(model=GENERATION_MODEL, config=types.GenerateContentConfig(response_modalities=["Text", "Image"]))
-        full_resp = chat.send_message([detailed_prompt, pil_image])
+        # AI generation with retry logic
+        max_retries = 2
+        full_resp = None
         
-        # Fix: Access the parts through the correct structure
+        for attempt in range(max_retries):
+            try:
+                chat = client.chats.create(model=GENERATION_MODEL, config=types.GenerateContentConfig(response_modalities=["Text", "Image"]))
+                full_resp = chat.send_message([detailed_prompt, pil_image])
+                break
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    raise e
+                print(f"AI generation attempt {attempt + 1} failed: {e}")
+        
+        # Optimized response parsing
         gen_parts = full_resp.candidates[0].content.parts
         
         combined_text = ""
         inline_images = []
+        
+        # Single pass through parts
         for part in gen_parts:
-            if part.text is not None:
+            if hasattr(part, 'text') and part.text:
                 combined_text += part.text + "\n"
-            if part.inline_data is not None:
-                img = Image.open(BytesIO(part.inline_data.data))
-                inline_images.append(img)
+            if hasattr(part, 'inline_data') and part.inline_data:
+                try:
+                    img = Image.open(BytesIO(part.inline_data.data))
+                    inline_images.append(img)
+                except Exception as e:
+                    print(f"Failed to process image: {e}")
+                    continue
         
         combined_text = combined_text.strip()
-
-        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()]
+        # More robust regex parsing
+        tools_match = re.search(r"TOOLS AND MATERIALS:\s*(.*?)\s*(?=STEPS:|$)", combined_text, re.DOTALL | re.IGNORECASE)
+        steps_match = re.search(r"STEPS[^:]*:\s*(.*)", combined_text, re.DOTALL | re.IGNORECASE)
+        
+        if not tools_match or not steps_match:
+            return jsonify({'error': 'AI response format error - could not parse tools and steps'}), 500
+            
+        tools_section = tools_match.group(1).strip()
+        steps_section = steps_match.group(1).strip()
+        
+        # Efficient list comprehension
+        tools_list = [line.strip().lstrip('- ').strip() for line in tools_section.split('\n') if line.strip()]
         parsed_steps = parse_numbered_steps(steps_section)
 
-        if len(parsed_steps) != len(inline_images): return jsonify({'error': 'AI response mismatch: Steps and images do not match.'}), 500
+        if len(parsed_steps) != len(inline_images): 
+            return jsonify({'error': f'AI response mismatch: {len(parsed_steps)} steps vs {len(inline_images)} images'}), 500
 
+        # Sequential processing with progress tracking
         final_steps = []
-        for i, step_info in enumerate(parsed_steps):
-            img_byte_arr = io.BytesIO()
-            inline_images[i].save(img_byte_arr, format='PNG')
-            img_path = f"users/{uid}/projects/{project_id}/steps/step_{i+1}_image.png"
-            img_url = upload_to_storage(img_byte_arr.getvalue(), img_path, 'image/png')
-            
-            narration_url = generate_tts_audio_and_upload(step_info['text'], uid, project_id, i + 1)
-            step_info.update({"imageUrl": img_url, "narrationUrl": narration_url, "isDone": False, "notes": ""})
-            final_steps.append(step_info)
+        session = requests.Session()  # Reuse session for uploads
+        
+        for i, (step_info, image) in enumerate(zip(parsed_steps, inline_images)):
+            try:
+                # Optimize image before upload
+                if image.mode == 'RGBA':
+                    image = image.convert('RGB')
+                
+                # Compress image to reduce upload time
+                img_byte_arr = io.BytesIO()
+                image.save(img_byte_arr, format='JPEG', quality=85, optimize=True)
+                img_path = f"users/{uid}/projects/{project_id}/steps/step_{i+1}_image.jpg"
+                
+                # Upload with timeout
+                img_url = upload_to_storage(img_byte_arr.getvalue(), img_path, 'image/jpeg')
+                
+                # Generate audio with timeout handling
+                try:
+                    narration_url = generate_tts_audio_and_upload(step_info['text'], uid, project_id, i + 1)
+                except Exception as audio_error:
+                    print(f"Audio generation failed for step {i+1}: {audio_error}")
+                    narration_url = ""  # Continue without audio if it fails
+                
+                step_info.update({
+                    "imageUrl": img_url, 
+                    "narrationUrl": narration_url, 
+                    "isDone": False, 
+                    "notes": ""
+                })
+                final_steps.append(step_info)
+                
+            except Exception as step_error:
+                print(f"Failed to process step {i+1}: {step_error}")
+                return jsonify({'error': f'Failed to process step {i+1}'}), 500
+        
+        # Single database update
+        update_data = {
+            "status": "ready", 
+            "toolsList": tools_list, 
+            "steps": final_steps, 
+            "selectedOption": selected_option or ""
+        }
         
-        update_data = {"status": "ready", "toolsList": tools_list, "steps": final_steps, "selectedOption": selected_option or ""}
         project_ref.update(update_data)
         
         return jsonify({"success": True, **update_data})
 
     except Exception as e:
-        print(traceback.format_exc())
-        return jsonify({'error': f"Failed to generate detailed guide: {e}"}), 500
+        print(f"Error in approve_project_plan: {traceback.format_exc()}")
+        return jsonify({'error': f"Failed to generate detailed guide: {str(e)}"}), 500
 
 @app.route('/api/projects', methods=['GET'])
 def list_projects():