Update app.py

app.py

@@ -7,6 +7,11 @@ import json
 import os
 import pandas as pd
 import pytz
+
+
+
+
+
 import random
 import re
 import shutil
@@ -20,10 +25,21 @@ from azure.cosmos import CosmosClient, exceptions
 from datetime import datetime
 from git import Repo
 from github import Github
+
 from gradio_client import Client
 from urllib.parse import quote
 
 
+# Add these imports at the top of your file
+from gradio_client import Client, handle_file
+import tempfile
+from PIL import Image
+import io
+import requests
+import numpy as np
+
+
+
 # 🎭 App Configuration - Because every app needs a good costume!
 Site_Name = '🐙GitCosmos🌌 - AI Azure Cosmos DB and Github Agent'
 title = "🐙GitCosmos🌌 - AI Azure Cosmos DB and Github Agent"
@@ -228,6 +244,7 @@ def save_to_cosmos_db(container, query, response1, response2):
 
 
 def save_to_cosmos_db_old(container, query, response1, response2):
+
     try:
         if container:
             record = {
@@ -557,6 +574,9 @@ def load_file_content(file_path):
     try:
         with open(file_path, 'r', encoding='utf-8') as file:
             return file.read()
+
+
+
     except Exception as e:
         st.error(f"Error loading file: {str(e)}")
         return None
@@ -743,6 +763,11 @@ def update_file_management_section():
                 
         with col2:
             st.markdown(get_download_link(file), unsafe_allow_html=True)
+
+
+
+
+
             
         with col3:
             if st.button("📂", key=f"edit_{file}"):
@@ -772,8 +797,233 @@ def update_file_management_section():
             display_file_editor(st.session_state.current_file)
 
 
+# Function to create HTML for autoplaying and looping video (for the full cinematic effect 🎥)
+def get_video_html(video_path, width="100%"):
+    video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
+    return f'''
+    <video width="{width}" controls autoplay muted loop>
+        <source src="{video_url}" type="video/mp4">
+        Your browser does not support the video tag.
+    </video>
+    '''
+
+
+
+
+# *********
+def validate_and_preprocess_image(file_data, target_size=(576, 1024)):
+    """Validate and preprocess image for video generation with improved BytesIO handling"""
+    try:
+        st.write("Starting image preprocessing...")
+        
+        # Handle different input types
+        if isinstance(file_data, bytes):
+            st.write("Processing bytes input")
+            img = Image.open(io.BytesIO(file_data))
+        elif hasattr(file_data, 'read'):
+            st.write("Processing file-like object")
+            # Reset file pointer if possible
+            if hasattr(file_data, 'seek'):
+                file_data.seek(0)
+            img = Image.open(file_data)
+        elif isinstance(file_data, Image.Image):
+            st.write("Processing PIL Image input")
+            img = file_data
+        else:
+            raise ValueError(f"Unsupported input type: {type(file_data)}")
+        
+        st.write(f"Successfully loaded image: {img.format}, size={img.size}, mode={img.mode}")
+        
+        # Convert to RGB if necessary
+        if img.mode != 'RGB':
+            st.write(f"Converting image from {img.mode} to RGB")
+            img = img.convert('RGB')
+        
+        # Calculate aspect ratio
+        aspect_ratio = img.size[0] / img.size[1]
+        st.write(f"Original aspect ratio: {aspect_ratio:.2f}")
+        
+        # Determine target dimensions maintaining aspect ratio
+        if aspect_ratio > target_size[0]/target_size[1]:  # Wider than target
+            new_width = target_size[0]
+            new_height = int(new_width / aspect_ratio)
+        else:  # Taller than target
+            new_height = target_size[1]
+            new_width = int(new_height * aspect_ratio)
+            
+        # Ensure dimensions are even numbers
+        new_width = (new_width // 2) * 2
+        new_height = (new_height // 2) * 2
+        
+        st.write(f"Resizing to: {new_width}x{new_height}")
+        
+        # Resize image using high-quality downsampling
+        resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # Create white background image of target size
+        final_img = Image.new('RGB', target_size, (255, 255, 255))
+        
+        # Calculate position to paste resized image (center)
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        
+        # Paste resized image onto white background
+        final_img.paste(resized_img, (paste_x, paste_y))
+        
+        st.write(f"Final image size: {final_img.size}")
+        return final_img
+        
+    except Exception as e:
+        st.error(f"Error in image preprocessing: {str(e)}\nType of input: {type(file_data)}")
+        return None
+
+def add_video_generation_ui(container):
+    """Enhanced video generation UI with improved file handling"""
+    st.markdown("### 🎥 Video Generation")
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        uploaded_file = st.file_uploader(
+            "Upload Image for Video Generation 🖼️",
+            type=['png', 'jpg', 'jpeg'],
+            help="Upload a clear, well-lit image. Recommended size: 576x1024 pixels."
+        )
+    
+    with col2:
+        st.markdown("#### Generation Parameters")
+        motion_bucket_id = st.slider(
+            "Motion Intensity 🌊",
+            min_value=1,
+            max_value=255,
+            value=127,
+            help="Lower values create subtle movement, higher values create more dramatic motion"
+        )
+        fps_id = st.slider(
+            "Frames per Second 🎬",
+            min_value=1,
+            max_value=30,
+            value=6,
+            help="Higher values create smoother but potentially less stable videos"
+        )
+        
+        with st.expander("Advanced Options"):
+            use_custom_seed = st.checkbox("Use Custom Seed")
+            if use_custom_seed:
+                seed = st.number_input("Seed Value", value=int(time.time() * 1000))
+            else:
+                seed = None
 
+    if uploaded_file is not None:
+        try:
+            # Read file data
+            file_data = uploaded_file.read()
+            
+            # Preview original image
+            preview_col1, preview_col2 = st.columns(2)
+            with preview_col1:
+                st.write("Original Image:")
+                original_img = Image.open(io.BytesIO(file_data))
+                st.image(original_img, caption="Original", use_column_width=True)
+            
+            # Preview preprocessed image
+            with preview_col2:
+                # Create a new BytesIO object with the file data
+                preprocessed = validate_and_preprocess_image(io.BytesIO(file_data))
+                if preprocessed:
+                    st.write("Preprocessed Image:")
+                    st.image(preprocessed, caption="Preprocessed", use_column_width=True)
+                else:
+                    st.error("Failed to preprocess image")
+                    return
+            
+            if st.button("🎥 Generate Video", help="Start video generation process"):
+                with st.spinner("Processing your video... This may take a few minutes 🎬"):
+                    # Save preprocessed image to temporary file
+                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_file:
+                        preprocessed.save(temp_file.name, format='PNG')
+                        st.write(f"Saved preprocessed image to temporary file: {temp_file.name}")
+                        
+                        try:
+                            # Initialize the Gradio client
+                            client = Client(
+                                "awacke1/stable-video-diffusion",
+                                hf_token=os.environ.get("HUGGINGFACE_TOKEN")
+                            )
+                            
+                            # Generate video
+                            result = client.predict(
+                                image=temp_file.name,
+                                seed=seed if seed is not None else int(time.time() * 1000),
+                                randomize_seed=seed is None,
+                                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 and os.path.exists(video_path):
+                                    # Save video locally
+                                    video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+                                    shutil.copy(video_path, video_filename)
+                                    
+                                    st.success(f"""
+                                    Video generated successfully! 🎉
+                                    - Seed: {seed if seed is not None else 'Random'}
+                                    - Motion Intensity: {motion_bucket_id}
+                                    - FPS: {fps_id}
+                                    """)
+                                    
+                                    st.video(video_filename)
+                                    
+                                    # Save to Cosmos DB
+                                    if container:
+                                        video_record = {
+                                            "id": generate_unique_id(),
+                                            "type": "generated_video",
+                                            "filename": video_filename,
+                                            "seed": seed if seed is not None else "random",
+                                            "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}")
+                                else:
+                                    st.error("Failed to generate video: Invalid result format")
+                            else:
+                                st.error("Failed to generate video: No result returned")
+                            
+                        except Exception as e:
+                            st.error(f"Error generating video: {str(e)}")
+                        finally:
+                            # Cleanup temporary file
+                            try:
+                                os.unlink(temp_file.name)
+                                st.write("Cleaned up temporary file")
+                            except Exception as e:
+                                st.warning(f"Error cleaning up temporary file: {str(e)}")
                 
+        except Exception as e:
+            st.error(f"Error processing uploaded file: {str(e)}")
+
+
+# ******************************************
+
+# Function to create HTML for audio player (when life needs a soundtrack 🎶)
+def get_audio_html(audio_path, width="100%"):
+    audio_url = f"data:audio/mpeg;base64,{base64.b64encode(open(audio_path, 'rb').read()).decode()}"
+    return f'''
+    <audio controls style="width: {width};">
+        <source src="{audio_url}" type="audio/mpeg">
+        Your browser does not support the audio element.
+    </audio>
+    '''
+        
 # 🎭 Main function - "All the world's a stage, and all the code merely players" -Shakespeare, probably
 def main():
     st.markdown("### 🐙Git🌌Cosmos💫 - Azure Cosmos DB and Github Agent")
@@ -1036,56 +1286,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)}")                                        
-
                         
                         
                         
@@ -1113,6 +1313,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 = []
@@ -1146,7 +1352,48 @@ def main():
                                         except Exception as e:
                                             st.error(f"Error saving document: {str(e)}")
 
-
+                        
+                            # File Editor (When you need to tweak things ✏️)
+                            if hasattr(st.session_state, 'current_file'):
+                                st.subheader(f"Editing: {st.session_state.current_file} 🛠")
+                                new_content = st.text_area("File Content ✏️:", st.session_state.file_content, height=300)
+                                if st.button("Save Changes 💾"):
+                                    with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
+                                        file.write(new_content)
+                                    st.success("File updated successfully! 🎉")
+                        
+                            # Image Gallery (For your viewing pleasure 📸)
+                            st.subheader("Image Gallery 🖼")
+                            image_files = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
+                            image_cols = st.slider("Gallery Columns 🖼", min_value=1, max_value=15, value=5)
+                            cols = st.columns(image_cols)
+                            for idx, image_file in enumerate(image_files):
+                                with cols[idx % image_cols]:
+                                    img = Image.open(image_file)
+                                    #st.image(img, caption=image_file, use_column_width=True)
+                                    st.image(img, use_column_width=True)
+                                    display_glossary_entity(os.path.splitext(image_file)[0])
+                        
+                            # Video Gallery (Let’s roll the tapes 🎬)
+                            st.subheader("Video Gallery 🎥")
+                            video_files = glob.glob("*.mp4")
+                            video_cols = st.slider("Gallery Columns 🎬", min_value=1, max_value=5, value=3)
+                            cols = st.columns(video_cols)
+                            for idx, video_file in enumerate(video_files):
+                                with cols[idx % video_cols]:
+                                    st.markdown(get_video_html(video_file, width="100%"), unsafe_allow_html=True)
+                                    display_glossary_entity(os.path.splitext(video_file)[0])
+                        
+                            # Audio Gallery (Tunes for the mood 🎶)
+                            st.subheader("Audio Gallery 🎧")
+                            audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
+                            audio_cols = st.slider("Gallery Columns 🎶", min_value=1, max_value=15, value=5)
+                            cols = st.columns(audio_cols)
+                            for idx, audio_file in enumerate(audio_files):
+                                with cols[idx % audio_cols]:
+                                    st.markdown(get_audio_html(audio_file, width="100%"), unsafe_allow_html=True)
+                                    display_glossary_entity(os.path.splitext(audio_file)[0])
+                                
 
 
                                                 
@@ -1377,6 +1624,15 @@ def main():
                 st.text_area("Claude replied 🤖:", chat["claude"], height=200, disabled=True)
                 st.markdown("---")
                 
+
+
+
+
+
+
+
+
+
             
             # 📝 File editor - "Edit with care, save with flair"
             if hasattr(st.session_state, 'current_file'):
@@ -1413,5 +1669,6 @@ def main():
         st.session_state.current_index = 0
         st.rerun()
 
+
 if __name__ == "__main__":
     main()