Update main.py

main.py

@@ -568,148 +568,116 @@ def create_project():
 def approve_project_plan(project_id):
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-    
+
     project_ref = db_ref.child(f'projects/{project_id}')
     project_data = project_ref.get()
     if not project_data or project_data.get('uid') != uid:
         return jsonify({'error': 'Project not found or access denied'}), 404
 
     selected_option = request.json.get('selectedOption')
-    
-    # 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']}'."
-
-    # 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..."""
+
+    # 1) Download & compress the user’s image before sending it off to Gemini
+    response = requests.get(project_data['userImageURL'])
+    pil_image = Image.open(io.BytesIO(response.content)).convert("RGB")
+    pil_image.thumbnail((1024, 1024))  # max‐side 1024px
+    buf = io.BytesIO()
+    pil_image.save(buf, format='JPEG', quality=75, optimize=True)
+    buf.seek(0)
+    compressed_image = Image.open(buf)
+
+    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:
+
+    TOOLS AND MATERIALS:
+    - Tool A
+    - Material B
+
+    STEPS(Maximum 7 steps):
+    1. First step instructions.
+    2. Second step instructions...
+    """
 
     try:
-        # AI generation with retry logic
-        max_retries = 2
-        full_resp = None
-        
-        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
+        chat = client.chats.create(
+            model=GENERATION_MODEL,
+            config=types.GenerateContentConfig(response_modalities=["Text", "Image"])
+        )
+        full_resp = chat.send_message([detailed_prompt, compressed_image])
+
         gen_parts = full_resp.candidates[0].content.parts
-        
         combined_text = ""
         inline_images = []
-        
-        # Single pass through parts
+
         for part in gen_parts:
-            if hasattr(part, 'text') and part.text:
+            if part.text:
                 combined_text += part.text + "\n"
-            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
-        
+            if part.inline_data:
+                img = Image.open(BytesIO(part.inline_data.data)).convert("RGB")
+                # 2) Immediately downscale each AI‐generated image
+                img.thumbnail((800, 800))
+                inline_images.append(img)
         combined_text = combined_text.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()]
+
+        # parse out tools + steps
+        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.splitlines() if line.strip()]
         parsed_steps = parse_numbered_steps(steps_section)
 
-        if len(parsed_steps) != len(inline_images): 
-            return jsonify({'error': f'AI response mismatch: {len(parsed_steps)} steps vs {len(inline_images)} images'}), 500
+        if len(parsed_steps) != len(inline_images):
+            return jsonify({'error': 'AI response mismatch: Steps and images do not match.'}), 500
 
-        # Sequential processing with progress tracking
         final_steps = []
-        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
+        for i, step_info in enumerate(parsed_steps):
+            # 3) Save JPEG at 70% quality
+            img_byte_arr = io.BytesIO()
+            inline_images[i].save(
+                img_byte_arr,
+                format='JPEG',
+                quality=70,
+                optimize=True
+            )
+            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')
+
+            # 4) Generate and compress TTS audio to mp3 @ 64kbps
+            raw_audio = generate_tts_audio(step_info['text'])  # returns raw bytes
+            from pydub import AudioSegment
+            sound = AudioSegment.from_file(io.BytesIO(raw_audio), format="wav")
+            mp3_buf = io.BytesIO()
+            sound.export(mp3_buf, format="mp3", bitrate="64k")
+            mp3_buf.seek(0)
+            narration_url = upload_to_storage(mp3_buf.read(),
+                                              f"users/{uid}/projects/{project_id}/steps/step_{i+1}_tts.mp3",
+                                              'audio/mpeg')
+
+            step_info.update({
+                "imageUrl": img_url,
+                "narrationUrl": narration_url,
+                "isDone": False,
+                "notes": ""
+            })
+            final_steps.append(step_info)
+
         update_data = {
-            "status": "ready", 
-            "toolsList": tools_list, 
-            "steps": final_steps, 
+            "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(f"Error in approve_project_plan: {traceback.format_exc()}")
-        return jsonify({'error': f"Failed to generate detailed guide: {str(e)}"}), 500
+        print(traceback.format_exc())
+        return jsonify({'error': f"Failed to generate detailed guide: {e}"}), 500
 
 @app.route('/api/projects', methods=['GET'])
 def list_projects():