Update app.py

app.py

@@ -35,6 +35,8 @@ from gradio_client import Client, handle_file
 import tempfile
 from PIL import Image
 import io
+import requests
+
 
 
 
@@ -812,48 +814,207 @@ def get_video_html(video_path, width="100%"):
 
 # *********
 
+def resize_image_for_video(image_data, max_size=(1024, 1024)):
+    """Resize image to be compatible with video generation"""
+    try:
+        # Convert bytes to PIL Image if needed
+        if isinstance(image_data, bytes):
+            img = Image.open(io.BytesIO(image_data))
+        elif isinstance(image_data, Image.Image):
+            img = image_data
+        else:
+            raise ValueError("Unsupported image data type")
 
+        # Convert to RGB if necessary
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
 
+        # Calculate new size maintaining aspect ratio
+        ratio = min(max_size[0] / img.size[0], max_size[1] / img.size[1])
+        new_size = tuple(int(dim * ratio) for dim in img.size)
+        
+        # Resize image
+        resized_img = img.resize(new_size, Image.Resampling.LANCZOS)
+        return resized_img
+    except Exception as e:
+        st.error(f"Error resizing image: {str(e)}")
+        return None
 
-
-def generate_video_from_image(image_data, seed=None, motion_bucket_id=127, fps_id=6):
-    """Generate video from image using Stable Video Diffusion"""
+def generate_video_from_image(image_data, seed=None, motion_bucket_id=127, fps_id=6, max_retries=3):
+    """Generate video from image using Stable Video Diffusion with improved error handling"""
+    temp_files = []  # Keep track of temporary files
     try:
-        # Create a temporary file to save the uploaded image
+        # Create progress bar
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        status_text.text("Preparing image...")
+        progress_bar.progress(10)
+
+        # Resize image
+        resized_img = resize_image_for_video(image_data)
+        if resized_img is None:
+            return None, None
+
+        # Save resized image to temporary file
         with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_img:
-            # If image_data is a PIL Image, convert to bytes
-            if isinstance(image_data, Image.Image):
-                img_byte_arr = io.BytesIO()
-                image_data.save(img_byte_arr, format='PNG')
-                temp_img.write(img_byte_arr.getvalue())
-            else:
-                temp_img.write(image_data)
-            temp_img_path = temp_img.name
+            temp_files.append(temp_img.name)
+            resized_img.save(temp_img.name, format='PNG')
 
-        # Initialize the Gradio client
-        client = Client("awacke1/stable-video-diffusion")
+        status_text.text("Connecting to video generation service...")
+        progress_bar.progress(20)
+
+        # Initialize the Gradio client with error handling
+        client = Client(
+            "awacke1/stable-video-diffusion",
+            hf_token=os.environ.get("HUGGINGFACE_TOKEN")  # Add your token if needed
+        )
 
         # Get random seed if none provided
         if seed is None:
-            seed = client.predict(api_name="/get_random_value")
-
-        # Generate video
-        result = client.predict(
-            image=temp_img_path,
-            seed=seed,
-            randomize_seed=True,
-            motion_bucket_id=motion_bucket_id,
-            fps_id=fps_id,
-            api_name="/video"
-        )
+            try:
+                seed = client.predict(api_name="/get_random_value")
+            except Exception as e:
+                st.warning(f"Could not get random seed, using default. Error: {str(e)}")
+                seed = int(time.time())  # Use timestamp as fallback
+
+        status_text.text("Generating video...")
+        progress_bar.progress(40)
 
-        # result[0] contains Dict with video path
-        video_path = result[0]['video']
-        return video_path, result[1]  # Return video path and used seed
+        # Attempt video generation with retries
+        error = None
+        for attempt in range(max_retries):
+            try:
+                status_text.text(f"Generating video (attempt {attempt + 1}/{max_retries})...")
+                progress_bar.progress(40 + (attempt * 20))
+
+                # First try to resize the image using the API
+                try:
+                    resized_result = client.predict(
+                        image=temp_img.name,
+                        api_name="/resize_image"
+                    )
+                    if resized_result:
+                        temp_files.append(resized_result)
+                        input_image = resized_result
+                    else:
+                        input_image = temp_img.name
+                except Exception as e:
+                    st.warning(f"Image resize API failed, using original image. Error: {str(e)}")
+                    input_image = temp_img.name
+
+                # Generate video
+                result = client.predict(
+                    image=input_image,
+                    seed=seed,
+                    randomize_seed=True,
+                    motion_bucket_id=motion_bucket_id,
+                    fps_id=fps_id,
+                    api_name="/video"
+                )
+
+                if result and isinstance(result, tuple) and len(result) >= 1:
+                    video_path = result[0].get('video') if isinstance(result[0], dict) else None
+                    if video_path:
+                        status_text.text("Video generated successfully!")
+                        progress_bar.progress(100)
+                        return video_path, seed
+
+                error = f"Invalid result format on attempt {attempt + 1}"
+                time.sleep(2 ** attempt)  # Exponential backoff
+            except Exception as e:
+                error = str(e)
+                st.warning(f"Attempt {attempt + 1} failed: {error}")
+                time.sleep(2 ** attempt)  # Exponential backoff
+
+        raise Exception(f"Failed after {max_retries} attempts. Last error: {error}")
 
     except Exception as e:
-        st.error(f"Error generating video: {str(e)}")
+        st.error(f"Error in video generation: {str(e)}")
         return None, None
+    finally:
+        # Cleanup temporary files
+        for temp_file in temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+            except Exception as e:
+                st.warning(f"Error cleaning up temporary file {temp_file}: {str(e)}")
+
+# Add this to your main Streamlit interface, in the appropriate section:
+def add_video_generation_ui(container):
+    """Add video generation UI components"""
+    st.markdown("### 🎥 Video Generation")
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        uploaded_image = st.file_uploader(
+            "Upload Image for Video Generation 🖼️",
+            type=['png', 'jpg', 'jpeg'],
+            help="Upload an image to generate a video from"
+        )
+    
+    with col2:
+        st.markdown("#### Parameters")
+        motion_bucket_id = st.slider(
+            "Motion Intensity 🌊",
+            min_value=1,
+            max_value=255,
+            value=127,
+            help="Controls the amount of motion in the generated video"
+        )
+        fps_id = st.slider(
+            "Frames per Second 🎬",
+            min_value=1,
+            max_value=30,
+            value=6,
+            help="Controls the smoothness of the generated video"
+        )
+
+    if uploaded_image:
+        st.image(uploaded_image, caption="Preview of uploaded image", use_column_width=True)
+        
+        if st.button("🎥 Generate Video", help="Click to start video generation"):
+            with st.spinner("Processing your video... This may take a few minutes 🎬"):
+                image_bytes = uploaded_image.read()
+                video_path, used_seed = generate_video_from_image(
+                    image_bytes,
+                    motion_bucket_id=motion_bucket_id,
+                    fps_id=fps_id
+                )
+                
+                if video_path:
+                    # Save video locally
+                    video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+                    try:
+                        shutil.copy(video_path, video_filename)
+                        
+                        # Display the generated video
+                        st.success(f"Video generated successfully! Seed: {used_seed}")
+                        st.video(video_filename)
+                        
+                        # Save to Cosmos DB
+                        if container:
+                            video_record = {
+                                "id": generate_unique_id(),
+                                "type": "generated_video",
+                                "filename": video_filename,
+                                "seed": used_seed,
+                                "motion_bucket_id": motion_bucket_id,
+                                "fps_id": fps_id,
+                                "timestamp": datetime.now().isoformat()
+                            }
+                            success, message = insert_record(container, video_record)
+                            if success:
+                                st.success("Video record saved to database!")
+                            else:
+                                st.error(f"Error saving video record: {message}")
+                    except Exception as e:
+                        st.error(f"Error saving video: {str(e)}")
+                else:
+                    st.error("Failed to generate video. Please try again with different parameters.")
+
 
 # Add this to the 'Show as Run AI' section in your main function, 
 # right after the "🤖 Run AI" button:
@@ -1180,56 +1341,6 @@ def main():
                                     except Exception as e:
                                         st.error(f"Error processing deletion: {str(e)}")
                         
-                        elif selected_view == 'Show as Code Editor - Old':
-                            Label = '#### 💻 Code editor view'
-                            st.markdown(Label)
-                            total_docs = len(documents)
-                            doc = documents[st.session_state.current_index]
-                            # st.markdown(f"#### Document ID: {doc.get('id', '')}")
-                            doc_str = st.text_area("Edit Document", 
-                                                  value=json.dumps(doc, indent=2), 
-                                                  height=300, 
-                                                  key=f'code_editor_{st.session_state.current_index}')
-                            
-                            col_prev, col_next = st.columns([1, 1])
-                            with col_prev:
-                                if st.button("⬅️ Previous", key='prev_code'):
-                                    if st.session_state.current_index > 0:
-                                        st.session_state.current_index -= 1
-                                        st.rerun()
-                            with col_next:
-                                if st.button("➡️ Next", key='next_code'):
-                                    if st.session_state.current_index < total_docs - 1:
-                                        st.session_state.current_index += 1
-                                        st.rerun()
-                            
-                            col_save, col_delete = st.columns([1, 1])
-                            with col_save:
-                                if st.button("💾 Save Changes", key=f'save_button_{st.session_state.current_index}'):
-                                    try:
-                                        updated_doc = json.loads(doc_str)
-                                        response = container.upsert_item(body=updated_doc)
-                                        if response:
-                                            st.success(f"Document {updated_doc['id']} saved successfully.")
-                                            st.session_state.selected_document_id = updated_doc['id']
-                                            st.rerun()
-                                    except Exception as e:
-                                        st.error(f"Error saving document: {str(e)}")
-                            
-                            with col_delete:
-                                if st.button("🗑️ Delete", key=f'delete_button_{st.session_state.current_index}'):
-                                    try:
-                                        current_doc = json.loads(doc_str)
-                                        # Direct deletion using container method with id and partition key
-                                        delete = container.delete_item(current_doc["id"], current_doc["id"])
-                                        if delete:
-                                            st.success(f"Document {current_doc['id']} deleted successfully.")
-                                            if st.session_state.current_index > 0:
-                                                st.session_state.current_index -= 1
-                                            st.rerun()
-                                    except Exception as e:
-                                        st.error(f"Error deleting document: {str(e)}")                                        
-
                         
                         
                         
@@ -1257,6 +1368,12 @@ def main():
                         
                                     # Save and AI operations columns
 
+                                    
+                                    # Video Generator call  -  the video generation UI for container:
+                                    add_video_generation_ui(container)
+
+
+
                                     if st.button("🤖 Run AI", key=f'run_with_ai_button_{idx}'):
                                         # Your existing AI processing code here
                                         values_with_space = []