Update app.py

app.py

@@ -16,17 +16,14 @@ import logging
 import uuid
 import subprocess
 from pathlib import Path
-import wikipedia  # using the PyPI wikipedia package
 import urllib.parse
 import pandas as pd
-from PyPDF2 import PdfReader
 import plotly.graph_objects as go
 import matplotlib.pyplot as plt
 from langchain_google_genai import ChatGoogleGenerativeAI
 # For PandasAI using a single dataframe
 from pandasai import SmartDataframe
 from pandasai.responses.response_parser import ResponseParser
-#from langchain_community.chat_models.sambanova import ChatSambaNovaCloud
 from pandasai.exceptions import InvalidOutputValueMismatch
 import base64
 import os
@@ -45,7 +42,7 @@ class StreamLitResponse(ResponseParser):
     def __init__(self, context):
         super().__init__(context)
         # Ensure the export directory exists
-        os.makedirs("/home/user/app/exports/charts", exist_ok=True)
+        os.makedirs("./exports/charts", exist_ok=True)
 
     def format_dataframe(self, result):
         """
@@ -56,7 +53,7 @@ class StreamLitResponse(ResponseParser):
             df = result['value']
             # Apply styling if desired
             styled_df = df.style
-            img_path = f"/home/user/app/exports/charts/{uuid.uuid4().hex}.png"
+            img_path = f"./exports/charts/{uuid.uuid4().hex}.png"
             dfi.export(styled_df, img_path)
         except Exception as e:
             print("Error in format_dataframe:", e)
@@ -71,7 +68,7 @@ class StreamLitResponse(ResponseParser):
         # Case 1: If it's a matplotlib figure
         if hasattr(img_value, "savefig"):
             try:
-                img_path = f"/home/user/app/exports/charts/{uuid.uuid4().hex}.png"
+                img_path = f"./exports/charts/{uuid.uuid4().hex}.png"
                 img_value.savefig(img_path, format="png")
                 return {'type': 'plot', 'value': img_path}
             except Exception as e:
@@ -85,7 +82,7 @@ class StreamLitResponse(ResponseParser):
         # Case 3: If it's a BytesIO object
         if isinstance(img_value, io.BytesIO):
             try:
-                img_path = f"/home/user/app/exports/charts/{uuid.uuid4().hex}.png"
+                img_path = f"./exports/charts/{uuid.uuid4().hex}.png"
                 with open(img_path, "wb") as f:
                     f.write(img_value.getvalue())
                 return {'type': 'plot', 'value': img_path}
@@ -100,7 +97,7 @@ class StreamLitResponse(ResponseParser):
                 if "base64," in img_value:
                     img_value = img_value.split("base64,")[1]
                 # Decode and save to file
-                img_path = f"/home/user/app/exports/charts/{uuid.uuid4().hex}.png"
+                img_path = f"./exports/charts/{uuid.uuid4().hex}.png"
                 with open(img_path, "wb") as f:
                     f.write(base64.b64decode(img_value))
                 return {'type': 'plot', 'value': img_path}
@@ -118,7 +115,7 @@ class StreamLitResponse(ResponseParser):
 
 guid = uuid.uuid4()
 new_filename = f"{guid}"
-user_defined_path = os.path.join("/exports/charts/", new_filename)
+user_defined_path = os.path.join("./exports/charts/", new_filename)
 
 img_ID = "344744a88ad1098"
 img_secret = "3c542a40c215327045d7155bddfd8b8bc84aebbf"
@@ -144,25 +141,22 @@ headers = {"Authorization": f"Bearer {token}"}
 
 # Pandasai gemini
 llm1 = ChatGoogleGenerativeAI(
-    model="gemini-2.0-flash-thinking-exp",
+    model="gemini-2.0-flash-thinking-exp", # MODEL REVERTED
     temperature=0,
     max_tokens=None,
     timeout=1000,
     max_retries=2
 )
 
-# Initialize the supdata client
-SUPADATA = os.getenv('SUPADATA')
-supadata = Supadata(api_key=f"{SUPADATA}")
 # -----------------------
 # Utility Constants
 # -----------------------
-MAX_CHARACTERS = 200000  # Approximate token limit: 50,000 tokens ~ 200,000 characters
+MAX_CHARACTERS = 200000
 
 def configure_gemini(api_key):
     try:
         genai.configure(api_key=api_key)
-        return genai.GenerativeModel('gemini-2.0-flash-thinking-exp')
+        return genai.GenerativeModel('gemini-2.0-flash-thinking-exp') # MODEL REVERTED
     except Exception as e:
         logger.error(f"Error configuring Gemini: {str(e)}")
         raise
@@ -172,60 +166,10 @@ model = configure_gemini(GOOGLE_API_KEY)
 os.environ["GEMINI_API_KEY"] = GOOGLE_API_KEY
 
 # -----------------------
-# File Upload Helpers
-# -----------------------
-def get_pdf_text(pdf_file):
-    """Extract text from a PDF file and enforce token limit."""
-    text = ""
-    pdf_reader = PdfReader(pdf_file)
-    for page in pdf_reader.pages:
-        page_text = page.extract_text()
-        if page_text:
-            text += page_text + "\n"
-    if len(text) > MAX_CHARACTERS:
-        text = text[:MAX_CHARACTERS]
-    return text
-
-
-# -----------------------
-# Audio Transcription
-# -----------------------
-
-def transcribe_audio(audio_file):
-    """
-    Transcribe audio using DeepGram's API (model: nova-3).
-    Expects a WAV audio file.
-    """
-    deepgram_api_key = os.getenv("DeepGram")
-    if not deepgram_api_key:
-        st.error("DeepGram API Key is missing. Please set DEEPGRAM_API_KEY in environment variables.")
-        return None
-    headers_transcribe = {
-        "Authorization": f"Token {deepgram_api_key}",
-        "Content-Type": "audio/wav"
-    }
-    url = "https://api.deepgram.com/v1/listen?model=nova-3"
-    try:
-        audio_bytes = audio_file.read()
-        response = requests.post(url, headers=headers_transcribe, data=audio_bytes)
-        if response.status_code == 200:
-            data = response.json()
-            transcription = data.get("text", "")
-            return transcription
-        else:
-            st.error(f"Deepgram transcription error: {response.status_code}")
-            return None
-    except Exception as e:
-        st.error(f"Error during transcription: {e}")
-        return None
-
-# -----------------------
-# PandasAI Response for DataFrame (using SmartDataframe and ChatSambaNovaCloud)
+# PandasAI Response for DataFrame
 # -----------------------
 def generateResponse(prompt, df):
-    
-    """Generate response using PandasAI with SmartDataframe and the ChatSambaNovaCloud LLM."""
-    
+    """Generate response using PandasAI with SmartDataframe."""
     pandas_agent = SmartDataframe(df, config={"llm": llm1,   "custom_whitelisted_dependencies": [
         "os",
         "io",
@@ -247,9 +191,6 @@ def generateResponse(prompt, df):
 def generate_story_from_dataframe(df, story_type):
     """
     Generate a data-based story from a CSV/Excel file.
-    The dataframe is converted to a JSON string and used as input in a prompt that instructs the model to produce
-    exactly 5 sections. Each section includes a brief analysis and an image description inside <>.
-    For dataframe stories, the image descriptions should be chart prompts based on the data.
     """
     df_json = json.dumps(df.to_dict())
     prompts = {
@@ -278,14 +219,13 @@ def generate_story_from_dataframe(df, story_type):
         if not response or not response.text:
             return None
 
-        # Ensure exactly 5 sections
         sections = response.text.split("[break]")
-        sections = [s.strip() for s in sections if s.strip()]  # Remove empty sections
+        sections = [s.strip() for s in sections if s.strip()]
 
         if len(sections) < 5:
-            sections += ["(Placeholder section)"] * (5 - len(sections))  # Fill missing sections
+            sections += ["(Placeholder section)"] * (5 - len(sections))
         elif len(sections) > 5:
-            sections = sections[:5]  # Trim excess sections
+            sections = sections[:5]
 
         return "[break]".join(sections)
 
@@ -293,171 +233,6 @@ def generate_story_from_dataframe(df, story_type):
         st.error(f"Error generating story from dataframe: {e}")
         return None
 
-
-# -----------------------
-# Existing Story Generation Functions (Text, Wikipedia, Bible, Youtube(new))
-# -----------------------
-def generate_story_from_text(prompt_text, story_type):
-    prompts = {
-        "free_form": "You are a professional storyteller. Based on the prompt: " + prompt_text + ", create an engaging and concise story. ",
-        "children": "You are a professional storyteller for children. Based on the prompt: " + prompt_text + ", create a fun and concise story. ",
-        "education": "You are a professional storyteller. Based on the prompt: " + prompt_text + ", create an educational and engaging story. ",
-        "business": "You are a professional storyteller. Based on the prompt: " + prompt_text + ", create a professional business story. ",
-        "entertainment": "You are a professional storyteller. Based on the prompt: " + prompt_text + ", create an entertaining and concise story. "
-    }
-    story_prompt = prompts.get(story_type, prompts["free_form"])
-    response = model.generate_content(
-        story_prompt +
-        "Write a short story for a narrator meaning no labels of pages or sections the story should just flow and narrated in 2 minutes or less. Divide your story into exactly 5 sections separated by [break]. For each section, include an image description inside <>."
-    )
-    return response.text if response else None
-
-def generate_story_from_wiki(wiki_url, story_type):
-    try:
-        page_title = wiki_url.rstrip("/").split("/")[-1]
-        wikipedia.set_lang("en")
-        page = wikipedia.page(page_title)
-        wiki_text = page.summary
-        prompts = {
-            "free_form": "You are a professional storyteller. Using the following Wikipedia info: " + wiki_text +
-                         ", create an engaging and concise story. ",
-            "children": "You are a professional storyteller for children. Using the following Wikipedia info: " + wiki_text +
-                         ", create a fun and concise story. ",
-            "education": "You are a professional storyteller. Using the following Wikipedia info: " + wiki_text +
-                         ", create an educational and engaging story. ",
-            "business": "You are a professional storyteller. Using the following Wikipedia info: " + wiki_text +
-                         ", create a professional business story. ",
-            "entertainment": "You are a professional storyteller. Using the following Wikipedia info: " + wiki_text +
-                         ", create an entertaining and concise story. "
-        }
-        story_prompt = prompts.get(story_type, prompts["free_form"])
-        response = model.generate_content(
-            story_prompt +
-            "Write a short story for a narrator meaning no labels of pages or sections the story should just flow and narrated in 2 minutes or less. Divide your story into exactly 5 sections separated by [break]. For each section, include an image description inside <>."
-        )
-        return response.text if response else None
-    except Exception as e:
-        st.error(f"Error generating story from Wikipedia: {e}")
-        return None
-
-def fetch_bible_text(reference):
-    m = re.match(r"(?P<book>[1-3]?\s*\w+(?:\s+\w+)*)\s+(?P<chapter>\d+)(?::(?P<verse_start>\d+)(?:-(?P<verse_end>\d+))?)?", reference)
-    if not m:
-        st.error("Bible reference format invalid. Use format like 'Genesis 1:1-5' or 'Psalms 23'.")
-        return None
-    book = m.group("book").strip().lower().replace(" ", "")
-    chapter = m.group("chapter")
-    verse_start = m.group("verse_start")
-    verse_end = m.group("verse_end")
-    if verse_start:
-        if verse_end is None:
-            verse_range = [verse_start]
-        else:
-            verse_range = [str(v) for v in range(int(verse_start), int(verse_end) + 1)]
-        verses_text = []
-        for verse in verse_range:
-            url = f"https://cdn.jsdelivr.net/gh/wldeh/bible-api/bibles/en-asv/books/{book}/chapters/{chapter}/verses/{verse}.json"
-            try:
-                response = requests.get(url)
-                if response.status_code == 200:
-                    data = response.json()
-                    verses_text.append(data.get("text", ""))
-                else:
-                    verses_text.append(f"[Error fetching verse {verse}]")
-            except Exception as e:
-                verses_text.append(f"[Exception fetching verse {verse}: {e}]")
-        return " ".join(verses_text)
-    else:
-        url = f"https://cdn.jsdelivr.net/gh/wldeh/bible-api/bibles/en-asv/books/{book}/chapters/{chapter}.json"
-        try:
-            response = requests.get(url)
-            if response.status_code == 200:
-                data = response.json()
-                if isinstance(data, list):
-                    verses = [verse.get("text", "") for verse in data]
-                    return " ".join(verses)
-                elif isinstance(data, dict) and "verses" in data:
-                    verses = [verse.get("text", "") for verse in data["verses"]]
-                    return " ".join(verses)
-                else:
-                    return str(data)
-            else:
-                st.error("Error fetching chapter text.")
-                return None
-        except Exception as e:
-            st.error(f"Exception fetching chapter: {e}")
-            return None
-
-def generate_story_from_bible(reference, story_type):
-    bible_text = fetch_bible_text(reference)
-    if bible_text is None:
-        return None
-    prompts = {
-        "free_form": "You are a professional storyteller. Using the following Bible text: " + bible_text +
-                     ", create an engaging and concise story. ",
-        "children": "You are a professional storyteller for children. Using the following Bible text: " + bible_text +
-                     ", create a fun and concise story. ",
-        "education": "You are a professional storyteller. Using the following Bible text: " + bible_text +
-                     ", create an educational and engaging story. ",
-        "business": "You are a professional storyteller. Using the following Bible text: " + bible_text +
-                     ", create a professional business story. ",
-        "entertainment": "You are a professional storyteller. Using the following Bible text: " + bible_text +
-                     ", create an entertaining and concise story. "
-    }
-    story_prompt = prompts.get(story_type, prompts["free_form"])
-    response = model.generate_content(
-        story_prompt +
-        "Write a short story for a narrator meaning no labels of pages or sections the story should just flow and narrated in 2 minutes or less. Divide your story into exactly 5 sections separated by [break]. For each section, include a brief image description inside <>."
-    )
-    return response.text if response else None
-
-
-def generate_story_from_youtube(youtube_url, story_type):
-    try:
-        # Extract video_id from the URL
-        if "v=" in youtube_url:
-            video_id = youtube_url.split("v=")[1].split("&")[0]
-        elif "youtu.be/" in youtube_url:
-            video_id = youtube_url.split("youtu.be/")[1].split("?")[0]
-        else:
-            raise ValueError("Invalid YouTube URL provided.")
-        
-        # Retrieve the transcript as a list of dictionaries
-        transcript_res = supadata.youtube.transcript(
-                video_id=video_id,
-                text=True
-            )
-        transcript_text = transcript_res.content
-        # Define story prompts based on story_type, similar to the Wikipedia function
-        prompts = {
-            "free_form": "You are a professional storyteller. Using the following YouTube transcript: " + transcript_text +
-                         ", create an engaging and concise story. ",
-            "children": "You are a professional storyteller for children. Using the following YouTube transcript: " + transcript_text +
-                         ", create a fun and concise story. ",
-            "education": "You are a professional storyteller. Using the following YouTube transcript: " + transcript_text +
-                         ", create an educational and engaging story. ",
-            "business": "You are a professional storyteller. Using the following YouTube transcript: " + transcript_text +
-                         ", create a professional business story. ",
-            "entertainment": "You are a professional storyteller. Using the following YouTube transcript: " + transcript_text +
-                         ", create an entertaining and concise story. "
-        }
-        # Use the provided story_type, defaulting to free_form if not found
-        story_prompt = prompts.get(story_type, prompts["free_form"])
-        
-        # Append additional instructions for story structure
-        full_prompt = story_prompt + (
-            "Write a short story for a narrator meaning no labels of pages or sections the story should just flow and narrated in 2 minutes or less. Divide your story into exactly 5 sections separated by [break]. "
-            "For each section, include an image description inside <>."
-        )
-        
-        # Generate content using your model (assumes model.generate_content is available)
-        response = model.generate_content(full_prompt)
-        return response.text if response else None
-
-    except Exception as e:
-        st.error(f"Error generating story from YouTube transcript: {e}")
-        return None
-
 # -----------------------
 # Extract Image Prompts and Story Sections
 # -----------------------
@@ -479,127 +254,72 @@ def extract_image_prompts_and_story(story_text):
     return pages, image_prompts
 
 def is_valid_png(file_path):
-    """Check if the PNG file at `file_path` is valid."""
     try:
         with open(file_path, "rb") as f:
-            # Read the first 8 bytes to check the PNG signature
             header = f.read(8)
             if header != b'\x89PNG\r\n\x1a\n':
                 return False
-            
-            # Attempt to open and verify the entire image
             with Image.open(file_path) as img:
-                img.verify()  # Verify the file integrity
+                img.verify()
             return True
     except Exception as e:
         print(f"Invalid PNG file at {file_path}: {e}")
         return False
 
-
 def standardize_and_validate_image(file_path):
-    """Validate, standardize, and overwrite the image at `file_path`."""
     try:
-        # Verify basic integrity
         with Image.open(file_path) as img:
             img.verify()
-        
-        # Reopen and convert to RGB
         with Image.open(file_path) as img:
-            img = img.convert("RGB")  # Remove alpha channel if present
-            
-            # Save to a temporary BytesIO buffer first
+            img = img.convert("RGB")
             buffer = io.BytesIO()
             img.save(buffer, format="PNG")
             buffer.seek(0)
-            
-            # Write the buffer to the file
             with open(file_path, "wb") as f:
                 f.write(buffer.getvalue())
-            
         return True
     except Exception as e:
         print(f"Failed to standardize/validate {file_path}: {e}")
         return False
 
 def generate_image(prompt_text, style, model="hf"):
-    """
-    Generate an image from a text prompt using either Hugging Face's, Pollinations Turbo's,
-    or Google's Gemini API.
-
-    Args:
-        prompt_text (str): The text prompt for image generation.
-        style (str or None): The style of the image (used for HF and Gemini models).
-        model (str): Which model to use ("hf" for Hugging Face, "pollinations_turbo" for Pollinations Turbo,
-                     or "gemini" for Google's Gemini).
-
-    Returns:
-        tuple: A tuple containing the generated PIL.Image and a Base64 string of the image.
-    """
     try:
         if model == "pollinations_turbo":
-            # URL-encode the prompt and add the query parameter to specify the model as "turbo"
             prompt_encoded = urllib.parse.quote(prompt_text)
             api_url = f"https://image.pollinations.ai/prompt/{prompt_encoded}?model=turbo"
             response = requests.get(api_url)
             if response.status_code != 200:
                 logger.error(f"Pollinations API error: {response.status_code}, {response.text}")
-                st.error(f"Error from image generation API: {response.status_code}")
                 return None, None
             image_bytes = response.content
             
         elif model == "gemini":
-            # For Google's Gemini model
             try:
-                
-                # Get API key from environment variable
                 g_api_key = os.getenv("GEMINI")
                 if not g_api_key:
-                    logger.error("GEMINI_API_KEY not found in environment variables")
-                    st.error("Google Gemini API key is missing. Please set the GEMINI_API_KEY environment variable.")
+                    st.error("Google Gemini API key is missing.")
                     return None, None
-                    
-                # Initialize Gemini client
                 client = genai.Client(api_key=g_api_key)
-                
-                # Enhance prompt with style
                 enhanced_prompt = f"image of {prompt_text} in {style} style, high quality, detailed illustration"
-                
-                # Generate content
                 response = client.models.generate_content(
-                    model="models/gemini-2.0-flash-exp",
+                    model="models/gemini-2.0-flash-exp", # MODEL REVERTED
                     contents=enhanced_prompt,
                     config=types.GenerateContentConfig(response_modalities=['Text', 'Image'])
                 )
-                
-                # Extract image from response
                 for part in response.candidates[0].content.parts:
                     if part.inline_data is not None:
                         image = Image.open(BytesIO(part.inline_data.data))
-                        
-                        # Convert to base64 string
                         buffered = io.BytesIO()
                         image.save(buffered, format="JPEG")
                         img_str = base64.b64encode(buffered.getvalue()).decode()
-                        
                         return image, img_str
-                
-                # If no image was found in the response
                 logger.error("No image was found in the Gemini API response")
-                st.error("Gemini API didn't return an image")
                 return None, None
-                
-            except ImportError:
-                logger.error("Google Gemini libraries not installed")
-                st.error("Google Gemini libraries not installed. Install with 'pip install google-genai'")
-                return None, None
-                
             except Exception as e:
                 logger.error(f"Gemini API error: {str(e)}")
-                st.error(f"Error from Gemini image generation: {str(e)}")
                 return None, None
                 
-        else:  # Default to Hugging Face model
-            # For Hugging Face model, include style details in the prompt
+        else:
             enhanced_prompt = f"{prompt_text} in {style} style, high quality, detailed illustration"
             model_id = "black-forest-labs/FLUX.1-dev"
             api_url = f"https://api-inference.huggingface.co/models/{model_id}"
@@ -607,11 +327,9 @@ def generate_image(prompt_text, style, model="hf"):
             response = requests.post(api_url, headers=headers, json=payload)
             if response.status_code != 200:
                 logger.error(f"Hugging Face API error: {response.status_code}, {response.text}")
-                st.error(f"Error from image generation API: {response.status_code}")
                 return None, None
             image_bytes = response.content
 
-        # For HF and Pollinations models that return image bytes
         if model != "gemini":
             image = Image.open(io.BytesIO(image_bytes))
             buffered = io.BytesIO()
@@ -620,25 +338,11 @@ def generate_image(prompt_text, style, model="hf"):
             return image, img_str
             
     except Exception as e:
-        st.error(f"Error generating image: {e}")
         logger.error(f"Image generation error: {str(e)}")
         
-    # Return a placeholder image in case of failure
     return Image.new('RGB', (1024, 1024), color=(200,200,200)), None
 
 def generate_image_with_retry(prompt_text, style, model="hf", max_retries=3):
-    """
-    Attempt to generate an image using generate_image, retrying up to max_retries if needed.
-
-    Args:
-        prompt_text (str): The text prompt for image generation.
-        style (str or None): The style of the image (ignored for Pollinations Turbo).
-        model (str): Which model to use ("hf" or "pollinations_turbo").
-        max_retries (int): Maximum number of retries.
-
-    Returns:
-        tuple: The generated image and its Base64 string.
-    """
     for attempt in range(max_retries):
         try:
             if attempt > 0:
@@ -664,18 +368,16 @@ def create_silent_video(images, durations, output_path, logo_path="sozo_logo2.pn
             st.error("Failed to create video file.")
             return None
 
-        # Load font for text overlay
         font_size = 45
         font = ImageFont.truetype(font_path, font_size)
 
-        # Load logo for fallback and full-screen display at the end
         logo = None
         if logo_path:
             logo = cv2.imread(logo_path)
             if logo is not None:
-                logo = cv2.resize(logo, (width, height))  # Resize logo to full screen
+                logo = cv2.resize(logo, (width, height))
             else:
-                st.warning(f"Failed to load logo from {logo_path}. No fallback image will be used.")
+                st.warning(f"Failed to load logo from {logo_path}.")
 
         for img, duration in zip(images, durations):
             try:
@@ -684,42 +386,31 @@ def create_silent_video(images, durations, output_path, logo_path="sozo_logo2.pn
                 frame = np.array(img_resized)
             except Exception as e:
                 print(f"Invalid image detected, replacing with logo: {e}")
-                if logo is not None:
-                    frame = logo  # Use the logo as a fallback
-                else:
-                    # If no logo is available, create a blank frame
-                    frame = np.zeros((height, width, 3), dtype=np.uint8)
+                frame = logo if logo is not None else np.zeros((height, width, 3), dtype=np.uint8)
 
-            # Convert to PIL for text drawing
             pil_img = Image.fromarray(frame)
             draw = ImageDraw.Draw(pil_img)
 
-            # Add "Sozo Dream Lab" text at bottom right
             text1 = "Made With"
-            text2 = "Sozo Dream Lab"
+            text2 = "Sozo Business Studio" # TEXT UPDATED
 
-            # Calculate the height of the first text to adjust the second text's position
             bbox = draw.textbbox((0, 0), text1, font=font)
-            text1_width = bbox[2] - bbox[0]
             text1_height = bbox[3] - bbox[1]
 
-            text_position1 = (width - 270, height - 120)  # position for "Made with"
-            text_position2 = (width - 330, height - 120 + text1_height + 5) # position for "Sozo dream lab", +5 for a little gap.
+            text_position1 = (width - 270, height - 120)
+            text_position2 = (width - 430, height - 120 + text1_height + 5) # Position adjusted for longer text
 
-            draw.text(text_position1, text1, font=font, fill=(81, 34, 97, 255))  # RGB: Purple
-            draw.text(text_position2, text2, font=font, fill=(81, 34, 97, 255))  # RGB: Purple
+            draw.text(text_position1, text1, font=font, fill=(81, 34, 97, 255))
+            draw.text(text_position2, text2, font=font, fill=(81, 34, 97, 255))
 
-            # Convert back to OpenCV format
             frame = np.array(pil_img)
             frame_cv = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
 
-            # Write frame multiple times to match duration
             for _ in range(int(duration * fps)):
                 video.write(frame_cv)
 
-        # Add full-screen logo frame at the end
         if logo is not None:
-            for _ in range(int(3 * fps)):  # Display for 3 seconds
+            for _ in range(int(3 * fps)):
                 video.write(logo)
 
         video.release()
@@ -729,7 +420,6 @@ def create_silent_video(images, durations, output_path, logo_path="sozo_logo2.pn
         st.error(f"Error creating silent video: {e}")
         return None
 
-
 def combine_video_audio(video_path, audio_files, output_path=None):
     try:
         if output_path is None:
@@ -765,46 +455,30 @@ def combine_video_audio(video_path, audio_files, output_path=None):
 
 def create_video(images, audio_files, output_path=None):
     try:
-        try:
-            subprocess.run(['ffmpeg', '-version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        except FileNotFoundError:
-            st.error("ffmpeg not installed.")
-            return None
-        if output_path is None:
-            output_path = f"output_video_{uuid.uuid4()}.mp4"
-        silent_video_path = f"silent_{uuid.uuid4()}.mp4"
-        durations = [get_audio_duration(af) if af else 5.0 for af in audio_files]
-        if len(durations) < len(images):
-            durations.extend([5.0]*(len(images)-len(durations)))
-        silent_video = create_silent_video(images, durations, silent_video_path)
-        if not silent_video:
-            return None
-        final_video = combine_video_audio(silent_video, audio_files, output_path)
-        try:
-            os.unlink(silent_video_path)
-        except Exception:
-            pass
-        return final_video
-    except Exception:
+        subprocess.run(['ffmpeg', '-version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except FileNotFoundError:
+        st.error("ffmpeg not installed.")
+        return None
+    if output_path is None:
+        output_path = f"output_video_{uuid.uuid4()}.mp4"
+    silent_video_path = f"silent_{uuid.uuid4()}.mp4"
+    durations = [get_audio_duration(af) if af else 5.0 for af in audio_files]
+    if len(durations) < len(images):
+        durations.extend([5.0]*(len(images)-len(durations)))
+    silent_video = create_silent_video(images, durations, silent_video_path)
+    if not silent_video:
         return None
+    final_video = combine_video_audio(silent_video, audio_files, output_path)
+    try:
+        os.unlink(silent_video_path)
+    except Exception:
+        pass
+    return final_video
 
 # -----------------------
 # Audio Generation Function
 # -----------------------
 def generate_audio(text, voice_model, audio_model="deepgram"):
-    """
-    Generate audio from text using either DeepGram or Pollinations OpenAI-Audio.
-
-    Args:
-        text (str): The text to convert to speech.
-        voice_model (str): The voice/model to use.
-            - For DeepGram, e.g., "aura-asteria-en" or "aura-helios-en".
-            - For Pollinations, e.g., "sage" (female) or "echo" (male).
-        audio_model (str): Which audio generation service to use ("deepgram" or "openai-audio").
-
-    Returns:
-        str or None: The path to the generated audio file, or None if generation failed.
-    """
     if audio_model == "deepgram":
         deepgram_api_key = os.getenv("DeepGram")
         if not deepgram_api_key:
@@ -825,7 +499,6 @@ def generate_audio(text, voice_model, audio_model="deepgram"):
             st.error(f"DeepGram TTS error: {response.status_code}")
             return None
     elif audio_model == "openai-audio":
-        # URL encode the text and call Pollinations TTS endpoint for openai-audio
         encoded_text = urllib.parse.quote(text)
         url = f"https://text.pollinations.ai/{encoded_text}?model=openai-audio&voice={voice_model}"
         response = requests.get(url)
@@ -842,14 +515,11 @@ def generate_audio(text, voice_model, audio_model="deepgram"):
         return None
 
 def get_audio_duration(audio_file):
-    import subprocess
     try:
         cmd = ['ffprobe', '-v', 'error', '-show_entries', 'format=duration',
                '-of', 'default=noprint_wrappers=1:nokey=1', audio_file]
         result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        if result.returncode != 0:
-            return 5.0
-        return float(result.stdout.strip())
+        return float(result.stdout.strip()) if result.returncode == 0 else 5.0
     except Exception:
         return 5.0
 
@@ -857,93 +527,46 @@ def get_audio_duration(audio_file):
 # Unified Process-Story Function
 # -----------------------
 def process_generated_story(style, voice_model):
-    """
-    Process the generated story by creating images and audio for each section.
-    For dataframe stories, it attempts to generate a chart image using PandasAI;
-    if that fails, it falls back on the default image generation.
-    This function now correctly handles images generated as file paths from base64,
-    matplotlib figures, or BytesIO objects.
-    """
-    # Add browser-like headers to avoid rate limiting
-    browser_headers = {
-        'User-Agent': ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
-                       'AppleWebKit/537.36 (KHTML, like Gecko) '
-                       'Chrome/91.0.4472.124 Safari/537.36')
-    }
-
-    # Extract story pages and image prompts
     pages, image_prompts = extract_image_prompts_and_story(st.session_state.full_story)
     st.session_state.story_pages = pages
     st.session_state.image_descriptions = image_prompts
     st.session_state.generated_images = []
     st.session_state.story_audio = []
     progress_bar = st.progress(0)
-    is_dataframe_story = st.session_state.dataframe is not None
+    total_steps = len(pages) * 2 # 1 for image, 1 for audio
+    current_step = 0
 
-    # Process each section sequentially: image then audio
     for i, (page, img_prompt) in enumerate(zip(pages, image_prompts)):
-        with st.spinner(f"Generating image {i+1} of {len(pages)}..."):
-            img = None  # Ensure img is always defined
-
-            if is_dataframe_story:
-                try:
-                    # generateResponse is expected to return a dict with type 'plot'
-                    chart_response = generateResponse("Generate this visualization: " + img_prompt,
-                                                        st.session_state.dataframe)
-                    if isinstance(chart_response, dict) and chart_response.get("type") == "plot":
-                        img_path = chart_response["value"]
-
-                        # Verify that the image file is valid (this will work for images saved from base64, matplotlib, or BytesIO)
-                        if isinstance(img_path, str) and os.path.isfile(img_path):
-                            if is_valid_png(img_path) and standardize_and_validate_image(img_path):
-                                img = Image.open(img_path)
-                            else:
-                                print(f"Invalid image file at {img_path}, generating default image")
-                                img, _ = generate_image_with_retry(img_prompt, style)
-                        else:
-                            print(f"Image file not found at {img_path}, generating default image")
-                            img, _ = generate_image_with_retry(img_prompt, style)
+        with st.spinner(f"Generating image {i+1}/{len(pages)}..."):
+            img = None
+            try:
+                chart_response = generateResponse("Generate this visualization: " + img_prompt, st.session_state.dataframe)
+                if isinstance(chart_response, dict) and chart_response.get("type") == "plot":
+                    img_path = chart_response["value"]
+                    if isinstance(img_path, str) and os.path.isfile(img_path) and is_valid_png(img_path) and standardize_and_validate_image(img_path):
+                        img = Image.open(img_path)
                     else:
-                        # Fallback if the response is not in expected dict format
-                        print("Not a valid plot response, generating default image")
                         img, _ = generate_image_with_retry(img_prompt, style)
-
-                except InvalidOutputValueMismatch as e:
-                    # Catch specific dataframe error and use fallback image generation
-                    st.warning(f"Skipping chart for section {i+1} due to invalid output type. Using default image instead.")
-                    img, _ = generate_image_with_retry(img_prompt, style)
-
-                except Exception as e:
-                    # General fallback for any other errors during dataframe processing
-                    st.warning(f"Chart generation failed for section {i+1}: {str(e)}")
+                else:
                     img, _ = generate_image_with_retry(img_prompt, style)
-            else:
-                # Process non-dataframe story flow
+            except Exception as e:
+                st.warning(f"Chart generation failed for section {i+1}: {e}. Using default image.")
                 img, _ = generate_image_with_retry(img_prompt, style)
+            
+            img = img if img else Image.new('RGB', (1024, 1024), color=(200, 200, 200))
+            st.session_state.generated_images.append(img.convert('RGB'))
+            current_step += 1
+            progress_bar.progress(current_step / total_steps)
 
-            # Ensure img is not None before appending; if None, create a blank image
-            if img is None:
-                img = Image.new('RGB', (1024, 1024), color=(200, 200, 200))
-            else:
-                img = img.convert('RGB')
-            st.session_state.generated_images.append(img)
-
-        # Update progress
-        progress_bar.progress((i + 1) / len(pages))
-        
-
-    # Audio generation (unchanged)
     for i, page in enumerate(pages):
-        with st.spinner(f"Generating audio {i+1} of {len(pages)}..."):
+        with st.spinner(f"Generating audio {i+1}/{len(pages)}..."):
             audio = generate_audio(page, voice_model, audio_model=audio_model_param)
             st.session_state.story_audio.append(audio)
+            current_step += 1
+            progress_bar.progress(current_step / total_steps)
 
-        # Update progress bar
-        progress_bar.progress((i + 1) / len(pages))
-
-    # Create video from the generated images and audio
     if st.session_state.generated_images:
-        with st.spinner("Creating video..."):
+        with st.spinner("Assembling video..."):
             audio_paths = [af for af in st.session_state.story_audio if af]
             if audio_paths:
                 st.session_state.final_video_path = create_video(st.session_state.generated_images, audio_paths)
@@ -951,211 +574,124 @@ def process_generated_story(style, voice_model):
                 silent_path = f"silent_video_{uuid.uuid4()}.mp4"
                 durations = [5.0] * len(st.session_state.generated_images)
                 st.session_state.final_video_path = create_silent_video(st.session_state.generated_images, durations, silent_path)
+    progress_bar.empty()
 # -----------------------
 # Display Generated Content
 # -----------------------
 def display_generated_content():
-    st.subheader("Generated Story")
-    tab1, tab2, tab3 = st.tabs(["Story Pages", "Full Story", "Video"])
+    st.subheader("Generated Narrative Video")
+    tab1, tab2, tab3 = st.tabs(["Video Output", "Story Pages", "Full Script"])
     
     with tab1:
-        for i, (page, img) in enumerate(zip(st.session_state.story_pages, st.session_state.generated_images)):
-            st.image(img, caption=f"Page {i+1}")
-            st.markdown(f"**Page {i+1}**: {page[:150]}{'...' if len(page)>150 else ''}")
-            if i < len(st.session_state.story_audio):
-                st.audio(st.session_state.story_audio[i])
-    
-    with tab2:
-        st.text_area("Complete Story", st.session_state.full_story, height=400)
-    
-    with tab3:
         if st.session_state.final_video_path and os.path.exists(st.session_state.final_video_path):
             with open(st.session_state.final_video_path, "rb") as f:
                 video_bytes = f.read()
             st.video(video_bytes)
-            st.download_button("Download Video", data=video_bytes, file_name="story_video.mp4", mime="video/mp4")
-            share_message = "Check out my AI generated story video! Download it from the attached link."
+            st.download_button("Download Video", data=video_bytes, file_name="sozo_business_narrative.mp4", mime="video/mp4")
+            share_message = "Check out this AI-generated business narrative video!"
             whatsapp_link = f"https://api.whatsapp.com/send?text={urllib.parse.quote(share_message)}"
-            st.markdown(f"[Share on WhatsApp with Video Attachment]({whatsapp_link})", unsafe_allow_html=True)
+            st.markdown(f"[Share on WhatsApp]({whatsapp_link})", unsafe_allow_html=True)
         else:
             st.error("Video file not found or not readable.")
 
+    with tab2:
+        for i, (page, img) in enumerate(zip(st.session_state.story_pages, st.session_state.generated_images)):
+            st.image(img, caption=f"Scene {i+1}")
+            st.markdown(f"**Narration {i+1}**: {page}")
+            if i < len(st.session_state.story_audio) and st.session_state.story_audio[i]:
+                st.audio(st.session_state.story_audio[i])
+    
+    with tab3:
+        st.text_area("Complete Narrative Script", st.session_state.full_story, height=400)
+    
+
 # -----------------------
 # Streamlit App Configuration and Sidebar
 # -----------------------
-st.set_page_config(page_title="Video Story Generator", page_icon="🎬", layout="wide", initial_sidebar_state="expanded")
-# Ensure session state keys are set.
+st.set_page_config(page_title="Sozo Business Studio", page_icon="💼", layout="wide", initial_sidebar_state="expanded")
+
 for key in ["story_pages", "image_descriptions", "generated_images", "story_audio", "full_story", "final_video_path", "dataframe"]:
     if key not in st.session_state:
-        st.session_state[key] = [] if key in ["story_pages", "image_descriptions", "generated_images", "story_audio"] else None
+        st.session_state[key] = [] if key.startswith("story") or key.startswith("generated") else None
 
 with st.sidebar:
     st.sidebar.image("sozo_logo1.jpeg", use_container_width=True)
-    # Story Type Selection
     story_types = {
+        "business": "Business Narrative",
+        "education": "Educational",
+        "entertainment": "Entertaining",
         "free_form": "Free Form (AI's choice)",
         "children": "Children's Story",
-        "education": "Educational",
-        "business": "Business Narrative",
-        "entertainment": "Entertaining"
-                }
+    }
     selected_story_type = st.selectbox(
-        "Story Type", 
+        "Narrative Style", 
         options=list(story_types.keys()),
         format_func=lambda x: story_types[x], 
-        index=0,
         key="story_type_select"
     )
     
-    # Image Generation Configuration
     model_options = ["HuggingFace Flux", "Pollinations Turbo", "Google Gemini"]
-    selected_model_name = st.selectbox(
-        "Select Image Generation Model", 
-        model_options, 
-        index=0, 
-        key="image_model_select"
-    )
+    selected_model_name = st.selectbox("Select Image Generation Model", model_options, index=0, key="image_model_select")
 
-    # Shared style options for all models
-    style_options = ["whimsical", "photorealistic", "cartoon", "concept art", "oil painting", "fantasy illustration", "cinematic"]
-    selected_style = st.selectbox(
-        "Image Style", 
-        style_options, 
-        index=0, 
-        key="style_select"
-    )
+    style_options = ["photorealistic", "cinematic", "cartoon", "concept art", "oil painting", "fantasy illustration", "whimsical"]
+    selected_style = st.selectbox("Image Style", style_options, key="style_select")
     
-    # Map the selected model name to the parameter value
-    if selected_model_name == "HuggingFace Flux":
-        model_param = "hf"
-    elif selected_model_name == "Pollinations Turbo":
-        model_param = "pollinations_turbo"
-    else:
-        model_param = "gemini"
+    model_param = {"HuggingFace Flux": "hf", "Pollinations Turbo": "pollinations_turbo", "Google Gemini": "gemini"}[selected_model_name]
     
-    # Audio Generation Configuration
     audio_model_options = ["DeepGram", "Pollinations OpenAI-Audio"]
-    selected_audio_model = st.selectbox(
-        "Select Audio Generation Model for Audio", 
-        audio_model_options, 
-        index=0, 
-        key="audio_model_select"
-    )
+    selected_audio_model = st.selectbox("Select Audio Generation Model", audio_model_options, key="audio_model_select")
     
     if selected_audio_model == "DeepGram":
-        deepgram_voice_options = {
-            "aura-asteria-en": "Female Voice (aura-asteria-en)",
-            "aura-helios-en": "Male Voice (aura-helios-en)"
-        }
-        selected_voice = st.selectbox(
-            "Voice Model for Audio Narration", 
-            options=list(deepgram_voice_options.keys()),
-            format_func=lambda x: deepgram_voice_options[x], 
-            index=0,
-            key="voice_select_deepgram"
-        )
+        voice_options = {"aura-asteria-en": "Female", "aura-helios-en": "Male"}
+        selected_voice = st.selectbox("Voice Model", options=list(voice_options.keys()), format_func=voice_options.get, key="voice_select_deepgram")
         audio_model_param = "deepgram"
     else:
-        pollinations_voice_options = {
-            "sage": "Female Voice (sage)",
-            "echo": "Male Voice (echo)"
-        }
-        selected_voice = st.selectbox(
-            "Voice Model for Audio Narration", 
-            options=list(pollinations_voice_options.keys()),
-            format_func=lambda x: pollinations_voice_options[x], 
-            index=0,
-            key="voice_select_pollinations"
-        )
+        voice_options = {"sage": "Female", "echo": "Male"}
+        selected_voice = st.selectbox("Voice Model", options=list(voice_options.keys()), format_func=voice_options.get, key="voice_select_pollinations")
         audio_model_param = "openai-audio"
         
     st.markdown("### Tips for Best Results")
-    st.markdown("""
-    - Use detailed prompts for best story generation.
-    - Try different image styles for varied visuals.
-    - Educational stories work well with Wikipedia, Bible, or file inputs.
-    - Choose a story type and voice that match your audience.
-    """)
+    st.markdown("- Ensure your data has clear column headers.\n- Use the 'Business Narrative' style for professional reports.\n- Try different image styles and voices to match your brand.")
     if st.button("Check System Requirements"):
         try:
             result = subprocess.run(['ffmpeg', '-version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            st.success("✅ ffmpeg is installed and working" if result.returncode==0 else "❌ ffmpeg error")
+            st.success("✅ ffmpeg is installed.")
         except FileNotFoundError:
-            st.error("❌ ffmpeg not installed.")
+            st.error("❌ ffmpeg not found. It must be installed to create videos.")
+
+# --- MAIN PAGE ---
+st.subheader("Sozo Business Studio")
+st.markdown("#### Turn business data into compelling narratives.")
+st.markdown("---")
+
+st.markdown("### 1. Upload Your Business Data")
+uploaded_file = st.file_uploader(
+    "Upload a CSV or Excel file to begin.", 
+    type=['csv', 'xlsx', 'xls'], 
+    label_visibility="collapsed"
+)
 
-st.subheader("🎬 Sozo. Dream Lab video story generator")
-st.markdown("Generate video stories from text, wikipedia, bible verses and more using AI.")
+if uploaded_file:
+    try:
+        df = pd.read_excel(uploaded_file) if uploaded_file.name.endswith(('xlsx', 'xls')) else pd.read_csv(uploaded_file)
+        st.session_state.dataframe = df
+        st.success(f"✅ Loaded `{uploaded_file.name}`. Data preview:")
+        st.dataframe(df.head())
+    except Exception as e:
+        st.error(f"Error processing {uploaded_file.name}: {e}")
+        st.session_state.dataframe = None
 
-# -----------------------
-# Input Method Selection
-# -----------------------
-input_method = st.radio("Choose input method:", 
-                        ["Text Prompt", "Wikipedia URL","Youtube URL", "Bible Reference", "Voice Input", "File Upload"])
-
-user_prompt = None
-wiki_url = None
-bible_reference = None
-youtube_url = None
-
-if input_method == "Text Prompt":
-    user_prompt = st.text_area("Enter a story prompt:", value="", placeholder="A magical adventure in an enchanted forest...")
-elif input_method == "Wikipedia URL":
-    wiki_url = st.text_input("Enter Wikipedia URL:", value="", placeholder="https://en.wikipedia.org/wiki/Elephant")
-elif input_method == "Youtube URL":
-    youtube_url = st.text_input("Enter Youtube URL:", value="", placeholder="https://www.youtube.com/watch?v=tKKxPtP6XjQ")
-elif input_method == "Bible Reference":
-    bible_reference = st.text_input("Enter Bible Reference (e.g. 'Genesis 1:1-5' or 'Psalms 23'):", value="")
-elif input_method == "Voice Input":
-    uploaded_audio = st.file_uploader("Record or upload your audio input (WAV format)", type=["wav"])
-    if uploaded_audio is not None:
-        transcription = transcribe_audio(uploaded_audio)
-        if transcription:
-            st.success("Transcription successful!")
-            user_prompt = st.text_area("Edit transcribed prompt:", value=transcription)
-        else:
-            st.error("Failed to transcribe audio.")
-elif input_method == "File Upload":
-    uploaded_file = st.file_uploader("Upload a PDF or CSV/Excel file", type=['pdf', 'csv', 'xlsx', 'xls'], accept_multiple_files=False)
-    if uploaded_file:
-        ext = uploaded_file.name.split(".")[-1].lower()
-        if ext == "pdf":
-            extracted_text = get_pdf_text(uploaded_file)
-            if extracted_text:
-                user_prompt = extracted_text
-        elif ext in ["csv", "xlsx", "xls"]:
-            try:
-                if ext == "csv":
-                    df = pd.read_csv(uploaded_file)
-                else:
-                    df = pd.read_excel(uploaded_file)
-                st.session_state.dataframe = df
-                
-            except Exception as e:
-                st.error(f"Error processing {uploaded_file.name}: {e}")
-
-if st.button("Generate Story"):
-    with st.spinner("Generating story..."):
-        if input_method == "Text Prompt" and user_prompt:
-            st.session_state.full_story = generate_story_from_text(user_prompt, selected_story_type)
-        elif input_method == "Wikipedia URL" and wiki_url:
-            st.session_state.full_story = generate_story_from_wiki(wiki_url, selected_story_type)
-        elif input_method == "Youtube URL" and youtube_url:
-            st.session_state.full_story = generate_story_from_youtube(youtube_url, selected_story_type)
-        elif input_method == "Bible Reference" and bible_reference:
-            st.session_state.full_story = generate_story_from_bible(bible_reference, selected_story_type)
-        elif input_method == "Voice Input" and user_prompt:
-            st.session_state.full_story = generate_story_from_text(user_prompt, selected_story_type)
-        elif input_method == "File Upload" and not st.session_state.full_story:
-            if user_prompt:  # PDF fallback
-                st.session_state.full_story = generate_story_from_text(user_prompt, selected_story_type)
-            elif st.session_state.dataframe is not None:
-                st.session_state.full_story = generate_story_from_dataframe(df, selected_story_type)
-        else:
-            st.error("Please provide valid input for the selected method.")
-        if st.session_state.full_story:
-            process_generated_story(selected_style, selected_voice)
-        else:
-            st.error("Failed to generate story. Please try a different prompt.")
+st.markdown("### 2. Generate Your Video")
+if st.button("Generate Video Narrative", disabled=st.session_state.dataframe is None):
+    with st.spinner("Analyzing data and generating narrative script..."):
+        st.session_state.full_story = generate_story_from_dataframe(st.session_state.dataframe, selected_story_type)
+    
+    if st.session_state.full_story:
+        st.success("Script generated! Now creating video assets...")
+        process_generated_story(selected_style, selected_voice)
+    else:
+        st.error("Failed to generate narrative script. The data might be formatted incorrectly or the AI model could be temporarily unavailable.")
 
 if st.session_state.story_pages:
+    st.markdown("---")
     display_generated_content()