text to video: v1

.gitignore

@@ -0,0 +1,162 @@
+.env
+venv/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+# db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

README.md

@@ -1,7 +1,7 @@
 ---
 title: Text To Video Generator
 emoji: 🚀
-colorFrom: blue
+colorFrom: green
 colorTo: yellow
 sdk: streamlit
 sdk_version: 1.42.0

app.py

@@ -0,0 +1,38 @@
+import streamlit as st
+from gradio_client import Client
+from utils import get_scenes, generate_video_assets, generate_video  # Import the function from utils.py
+
+# Streamlit app
+st.title("Text to Video Generator")
+
+# Text input box with a max of 1500 characters
+text_script = st.text_area("Enter your text (max 1500 characters):", max_chars=1500)
+
+
+# Initialize the client with the hosted model
+client = Client("habib926653/Multilingual-TTS")
+
+# Dropdown for language selection
+language = st.selectbox("Choose Language:", ["Urdu", "English"])  # Add more languages as needed
+
+# Get available speakers for the selected language
+speakers_response = client.predict(language=language, api_name="/get_speakers")
+
+# Extract speakers list
+speakers = [choice[0] for choice in speakers_response["choices"]]
+selected_speaker = st.selectbox("Choose Speaker:", speakers)
+
+
+
+# Button to trigger the processing
+if st.button("Generate Video"):
+    if text_script:
+        # Call the function from utils.py to process the text
+        scenes = get_scenes(text_script)
+        video_assets_folder = generate_video_assets(scenes, language, selected_speaker)
+        st.write(video_assets_folder)
+        generated_video_path = generate_video(video_assets_folder)
+        st.video(generated_video_path)
+
+    else:
+        st.warning("Please enter some text to generate prompts.")

constants.py

@@ -0,0 +1,14 @@
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+HF_TOKEN = os.getenv("HF_TOKEN", None)
+
+SUMMARIZATION_ENDPOINT="https://habib926653-text-translator-agent-api.hf.space/generate"
+IMAGE_GENERATION_SPACE_NAME="habib926653/stabilityai-stable-diffusion-3.5-large-turbo"
+
+# Supported formats
+SUPPORTED_FORMATS = ["mp3", "wav", "ogg", "flac", "aac", "m4a"]
+
+

env.example

@@ -0,0 +1,2 @@
+HF_TOKEN=HUGGING_FACE_TOKEN
+GROQ_API_KEY=GROQ_API_KEY

requirements.txt

@@ -0,0 +1,85 @@
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.8.0
+attrs==24.3.0
+audeer==2.2.1
+audiofile==1.5.1
+audmath==1.4.1
+blinker==1.9.0
+cachetools==5.5.0
+certifi==2024.12.14
+cffi==1.17.1
+charset-normalizer==3.4.1
+click==8.1.8
+decorator==4.4.2
+distro==1.9.0
+exceptiongroup==1.2.2
+filelock==3.16.1
+fsspec==2024.12.0
+gitdb==4.0.12
+GitPython==3.1.44
+gradio_client==1.5.4
+groq==0.15.0
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.27.1
+idna==3.10
+imageio==2.36.1
+imageio-ffmpeg==0.5.1
+Jinja2==3.1.5
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+langchain-core==0.3.29
+langchain-groq==0.2.3
+langgraph==0.2.62
+langgraph-checkpoint==2.0.9
+langgraph-sdk==0.1.51
+langsmith==0.2.10
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+moviepy==1.0.3
+msgpack==1.1.0
+narwhals==1.21.1
+numpy==2.2.1
+opencv-python==4.10.0.84
+orjson==3.10.14
+packaging==24.2
+pandas==2.2.3
+pillow==11.1.0
+proglog==0.1.10
+protobuf==5.29.3
+pyarrow==18.1.0
+pycparser==2.22
+pydantic==2.10.5
+pydantic_core==2.27.2
+pydeck==0.9.1
+pydub==0.25.1
+Pygments==2.19.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2024.2
+PyYAML==6.0.2
+referencing==0.35.1
+requests==2.32.3
+requests-toolbelt==1.0.0
+rich==13.9.4
+rpds-py==0.22.3
+scipy==1.15.1
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+soundfile==0.13.0
+streamlit==1.41.1
+tenacity==9.0.0
+toml==0.10.2
+tornado==6.4.2
+tqdm==4.67.1
+typing_extensions==4.12.2
+tzdata==2024.2
+urllib3==2.3.0
+watchdog==6.0.0
+websockets==14.1

response_schemas.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class SingleScene(BaseModel):
+    text: str = Field(description="Actual Segment of text from the complete story")
+    image_prompts: List[str] = Field(
+        description="""List of detailed and descriptive image prompts for the segment
+        prompt format: [theme: {atmosphere/mood}] [style: {artistic/photorealistic}] [focus: {main subject}] [details: {specific elements}] [lighting: {day/night/mystic}] [perspective: {close-up/wide-angle}]"
+    Example: "theme: eerie forest | style: cinematic realism | focus: abandoned cabin | details: broken windows, overgrown vines | lighting: moonlit fog | perspective: wide-angle shot"
+    """
+    )
+
+class ScenesResponseSchema(BaseModel):
+    scenes: List[SingleScene]

structured_output_extractor.py

@@ -0,0 +1,102 @@
+from typing import Type, Optional
+from pydantic import BaseModel
+from langgraph.graph import StateGraph, START, END
+from typing import TypedDict
+import constants  # Assuming constants.py holds LLM provider configurations
+from langchain_groq import ChatGroq
+
+
+# Define the State structure (similar to previous definition)
+class State(TypedDict):
+    messages: list
+    output: Optional[BaseModel]
+
+
+# Generic Pydantic model-based structured output extractor
+class StructuredOutputExtractor:
+    def __init__(self, response_schema: Type[BaseModel]):
+        """
+        Initializes the extractor for any given structured output model.
+        
+        :param response_schema: Pydantic model class used for structured output extraction
+        """
+        self.response_schema = response_schema
+
+        # Initialize language model (provider and API keys come from constants.py)
+        # self.llm = ChatGroq(model="llama-3.3-70b-versatile")  # token limit 100k tokens
+        self.llm = ChatGroq(model="deepseek-r1-distill-llama-70b")  # currently no limit per day
+        
+        # Bind the model with structured output capability
+        self.structured_llm = self.llm.with_structured_output(response_schema)
+        
+        # Build the graph for structured output
+        self._build_graph()
+
+    def _build_graph(self):
+        """
+        Build the LangGraph computational graph for structured extraction.
+        """
+        graph_builder = StateGraph(State)
+
+        # Add nodes and edges for structured output
+        graph_builder.add_node("extract", self._extract_structured_info)
+        graph_builder.add_edge(START, "extract")
+        graph_builder.add_edge("extract", END)
+
+        self.graph = graph_builder.compile()
+
+    def _extract_structured_info(self, state: dict):
+        """
+        Extract structured information using the specified response model.
+        
+        :param state: Current graph state
+        :return: Updated state with structured output
+        """
+        query = state['messages'][-1].content
+        print(f"Processing query: {query}")
+        try:
+            # Extract details using the structured model
+            output = self.structured_llm.invoke(query)
+            # Return the structured response
+            return {"output": output}
+        except Exception as e:
+            print(f"Error during extraction: {e}")
+            return {"output": None}
+
+    def extract(self, query: str) -> Optional[BaseModel]:
+        """
+        Public method to extract structured information.
+        
+        :param query: Input query for structured output extraction
+        :return: Structured model object or None
+        """
+        from langchain_core.messages import SystemMessage
+
+        result = self.graph.invoke({
+            "messages": [SystemMessage(content=query)]
+        })
+        # Return the structured model response, if available
+        result = result.get('output')
+        return result
+
+
+if __name__ == '__main__':
+        
+        # Example Pydantic model (e.g., Movie)
+        class Movie(BaseModel):
+            title: str
+            year: int
+            genre: str
+            rating: Optional[float] = None
+            actors: list[str] = []
+
+
+        # Example usage with a generic structured extractor
+        extractor = StructuredOutputExtractor(response_schema=Movie)
+
+        query = "Tell me about the movie Inception. Provide details about its title, year, genre, rating, and main actors."
+
+        result = extractor.extract(query)
+        print(type(result))
+        if result:
+            print(result)

utils.py

@@ -0,0 +1,419 @@
+import constants
+import os
+from PIL import Image
+from gradio_client import Client
+import moviepy.editor as mp
+from moviepy.video.VideoClip import ImageClip
+from moviepy.editor import AudioFileClip
+from structured_output_extractor import StructuredOutputExtractor
+from response_schemas import ScenesResponseSchema
+from typing import List, Dict
+import tempfile
+import os
+ 
+
+def get_scenes(text_script: str):
+
+    prompt = f"""
+    ROLE: Story to Scene Generator
+    Tasks: For the given story
+    1. Read it Completely and Understand the Complete Context
+    2. Rewrite the story in tiny segments(but without even changing a word) and a descriptive image or list of image prompts to visualize each segment
+    3. Make sure each image prompt matches the theme of overall scene and ultimately the story 
+    4. If necessary, a scene can have more than one image prompts
+
+    Here is the Complete Story: {text_script}
+    """
+    
+    
+    extractor = StructuredOutputExtractor(response_schema=ScenesResponseSchema)
+    result = extractor.extract(prompt)
+    return result.model_dump()   # returns dictionary version pydantic model
+
+
+
+
+# def generate_video_assets(scenes: Dict, language: str, speaker: str, base_path: str = "media"):
+#     """
+#     Generate video assets (images and audio) for each scene in a structured folder hierarchy.
+
+#     Args:
+#         scenes (Dict): A dictionary containing a list of scenes under the key "scenes".
+#         language (str): The language code for audio generation.
+#         speaker (str): The speaker for audio generation.
+#         base_path (str): The base folder where all assets will be stored. Default is "media".
+
+#     Returns:
+#         Dict: A dictionary containing the paths to the generated assets.
+#     """
+#     try:
+#         # Ensure the base folder exists
+#         if not os.path.exists(base_path):
+#             os.makedirs(base_path)
+
+#         # Extract scenes from the input dictionary
+#         scenes_list = scenes.get("scenes", [])
+#         print(f"Total Scenes: {len(scenes_list)}")
+
+#         # Dictionary to store asset paths
+#         assets = {"scenes": []}
+
+#         # Create a folder for the current video
+#         video_folder = os.path.join(base_path, f"video_{len(os.listdir(base_path)) + 1}")
+#         if not os.path.exists(video_folder):
+#             os.makedirs(video_folder)
+
+#         # Create 'images' and 'audio' folders inside the video folder
+#         images_folder = os.path.join(video_folder, "images")
+#         audio_folder = os.path.join(video_folder, "audio")
+#         os.makedirs(images_folder, exist_ok=True)
+#         os.makedirs(audio_folder, exist_ok=True)
+
+#         for scene_count, scene in enumerate(scenes_list):
+#             text: str = scene.get("text", "")
+#             image_prompts: List[str] = scene.get("image_prompts", [])
+
+#             # Create a folder for the current scene inside the 'images' folder
+#             scene_images_folder = os.path.join(images_folder, f"scene_{scene_count + 1}")
+#             os.makedirs(scene_images_folder, exist_ok=True)
+
+#             # Generate audio for the scene
+#             audio_path = os.path.join(audio_folder, f"scene_{scene_count + 1}.mp3")
+#             audio_result = generate_audio(text, language, speaker, path=audio_path)
+
+#             if "error" in audio_result:
+#                 print(f"Error generating audio for scene {scene_count + 1}: {audio_result['error']}")
+#                 continue
+
+#             # Generate images for the scene
+#             image_paths = []
+#             for count, prompt in enumerate(image_prompts):
+#                 image_path = os.path.join(scene_images_folder, f"scene_{scene_count + 1}_image_{count + 1}.png")
+#                 image_result = generate_image(prompt=prompt, path=image_path)
+
+#                 if "error" in image_result:
+#                     print(f"Error generating image {count + 1} for scene {scene_count + 1}: {image_result['error']}")
+#                 else:
+#                     image_paths.append(image_path)
+
+#             # Add the scene's asset paths to the dictionary
+#             assets["scenes"].append({
+#                 "scene_number": scene_count + 1,
+#                 "audio_path": audio_path,
+#                 "image_paths": image_paths
+#             })
+
+#             print(f"Scene: {scene_count + 1}\t No of Images in Scene {scene_count + 1}: {len(image_paths)}")
+
+#         return assets
+
+#     except Exception as e:
+#         print(f"Error during video asset generation: {e}")
+#         return {"error": str(e)}
+
+def generate_video_assets(scenes: Dict, language: str, speaker: str, base_path: str = "media") -> str:
+    try:
+        # Ensure the base folder exists
+        if not os.path.exists(base_path):
+            os.makedirs(base_path)
+
+        # Extract scenes from the input dictionary
+        scenes_list = scenes.get("scenes", [])
+        print(f"Total Scenes: {len(scenes_list)}")
+
+        # Create a folder for the current video
+        video_folder = os.path.join(base_path, f"video_{len(os.listdir(base_path)) + 1}")
+        if not os.path.exists(video_folder):
+            os.makedirs(video_folder)
+
+        # Create 'images' and 'audio' folders inside the video folder
+        images_folder = os.path.join(video_folder, "images")
+        audio_folder = os.path.join(video_folder, "audio")
+        os.makedirs(images_folder, exist_ok=True)
+        os.makedirs(audio_folder, exist_ok=True)
+
+        for scene_count, scene in enumerate(scenes_list):
+            text: str = scene.get("text", "")
+            image_prompts: List[str] = scene.get("image_prompts", [])
+
+            # Create a folder for the current scene inside the 'images' folder
+            scene_images_folder = os.path.join(images_folder, f"scene_{scene_count + 1}")
+            os.makedirs(scene_images_folder, exist_ok=True)
+
+            # Generate audio for the scene
+            audio_path = os.path.join(audio_folder, f"scene_{scene_count + 1}.mp3")
+            audio_result = generate_audio(text, language, speaker, path=audio_path)
+
+            if "error" in audio_result:
+                print(f"Error generating audio for scene {scene_count + 1}: {audio_result['error']}")
+                continue
+
+            # Generate images for the scene
+            image_paths = []
+            for count, prompt in enumerate(image_prompts):
+                image_path = os.path.join(scene_images_folder, f"scene_{scene_count + 1}_image_{count + 1}.png")
+                image_result = generate_image(prompt=prompt, path=image_path)
+
+                if "error" in image_result:
+                    print(f"Error generating image {count + 1} for scene {scene_count + 1}: {image_result['error']}")
+                else:
+                    image_paths.append(image_path)
+
+            print(f"Scene: {scene_count + 1}\t No of Images in Scene {scene_count + 1}: {len(image_paths)}")
+
+        # Return the path of the main video folder
+        return video_folder
+
+    except Exception as e:
+        print(f"Error during video asset generation: {e}")
+        return {"error": str(e)}
+
+
+def generate_audio(text, language_code, speaker, path='test_audio.mp3'):
+    try:
+        # Initialize the Gradio Client with the hosted model
+        client = Client("habib926653/Multilingual-TTS")
+
+        # Make the API request
+        result = client.predict(
+            text=text,  # Text input for audio generation
+            language_code=language_code,  # Language code (e.g., "Urdu")
+            speaker=speaker,  # Selected speaker (e.g., "Asad")
+            api_name="/text_to_speech_edge"
+        )
+
+        # The result is a tuple: (text, audio_file_path)
+        audio_file_path = result[1]  # The generated audio file path
+
+        # Read the audio file as bytes
+        with open(audio_file_path, 'rb') as f:
+            audio_bytes = f.read()
+
+        # Save the audio bytes to the specified path
+        with open(path, 'wb') as f:
+            f.write(audio_bytes)
+
+        # Return the result (which includes the file path)
+        return {"audio_file": path}
+
+    except Exception as e:
+        print(f"Error during audio generation: {e}")
+        return {"error": str(e)}
+
+
+def generate_image(prompt, path='test_image.png'):
+    try:
+        # Initialize the Gradio Client with Hugging Face token
+        client = Client(constants.IMAGE_GENERATION_SPACE_NAME, hf_token=constants.HF_TOKEN)
+
+        # Make the API request
+        result = client.predict(
+            prompt=prompt,  # Text prompt for image generation
+            width=1280,
+            height=720,
+            api_name="/generate_image"
+        )
+
+        image = Image.open(result)
+        image.save(path)
+
+        # Return the result (which includes the URL or file path)
+        return result
+
+    except Exception as e:
+        print(f"Error during image generation: {e}")
+        return {"error": str(e)}
+    
+def generate_images(image_prompts, folder_name='test_folder'):
+    folder_path = tmp_folder(folder_name)
+    for index, prompt in enumerate(image_prompts):
+        print(index, prompt)
+        image_path = generate_image(prompt=prompt, path=f"{folder_path}/{index}.png")
+        yield prompt, image_path
+    
+
+
+def tmp_folder(folder_name: str) -> str:
+    # Use the current working directory or any other accessible path for temp folders
+    base_tmp_path = os.path.join(os.getcwd(), "tmp_dir")  # Change this to any path you prefer
+    
+    # Ensure that the base temp folder exists
+    if not os.path.exists(base_tmp_path):
+        os.makedirs(base_tmp_path)
+        print(f"Base temporary folder '{base_tmp_path}' created.")
+    
+    # Define the path for the specific temporary folder
+    folder_path = os.path.join(base_tmp_path, folder_name)
+    
+    # Create the specific temporary folder if it doesn't exist
+    os.makedirs(folder_path, exist_ok=True)
+    
+    print(f"Temporary folder '{folder_name}' is ready at {folder_path}.")
+    
+    return folder_path
+
+
+
+from moviepy.editor import *
+
+
+import os
+import tempfile
+from moviepy.editor import AudioFileClip, ImageClip, concatenate_videoclips
+
+
+
+def generate_video(video_folder: str, output_filename: str = "final_video.mp4"):
+    audio_folder = os.path.join(video_folder, "audio")
+    images_folder = os.path.join(video_folder, "images")
+    final_clips = []
+    
+    # Get all scene folders
+    scene_folders = sorted(os.listdir(images_folder))
+    
+    for scene in scene_folders:
+        scene_path = os.path.join(images_folder, scene)
+        audio_path = os.path.join(audio_folder, f"{scene}.mp3")
+        
+        if not os.path.exists(audio_path):
+            print(f"Warning: Audio file {audio_path} not found. Skipping scene {scene}.")
+            continue
+        
+        # Get all images for the scene
+        image_files = sorted([os.path.join(scene_path, img) for img in os.listdir(scene_path) if img.endswith(('.png', '.jpg', '.jpeg'))])
+        
+        if not image_files:
+            print(f"Warning: No images found in {scene_path}. Skipping scene {scene}.")
+            continue
+        
+        # Load audio file
+        audio_clip = mp.AudioFileClip(audio_path)
+        
+        # Calculate duration per image
+        duration_per_image = audio_clip.duration / len(image_files)
+        
+        # Create image clips
+        image_clips = [mp.ImageClip(img).set_duration(duration_per_image) for img in image_files]
+        
+        # Concatenate image clips
+        scene_video = mp.concatenate_videoclips(image_clips, method="compose").set_audio(audio_clip)
+        
+        final_clips.append(scene_video)
+    
+    if not final_clips:
+        print("Error: No valid scenes processed.")
+        return None
+    
+    # Concatenate all scenes
+    final_video = mp.concatenate_videoclips(final_clips, method="compose")
+    output_path = os.path.join(video_folder, output_filename)
+    final_video.write_videofile(output_path, fps=24, codec='libx264')
+    
+    return output_path
+
+def generate_video_old(audio_file, images, segments):
+    try:
+        # Save the uploaded audio file to a temporary location
+        file_extension = os.path.splitext(audio_file.name)[1]
+        temp_audio_path = tempfile.NamedTemporaryFile(delete=False, suffix=f"{file_extension}")
+        temp_audio_path.write(audio_file.read())
+        temp_audio_path.close()
+
+        # Load the audio file using MoviePy
+        audio = AudioFileClip(temp_audio_path.name)
+
+        # Define YouTube-like dimensions (16:9 aspect ratio)
+        frame_width = 1280
+        frame_height = 720
+
+        video_clips = []
+        total_segments = len(segments)
+
+        for i, current_segment in enumerate(segments):
+            start_time = current_segment["start"]
+            end_time = current_segment["end"]
+            
+            # Calculate the actual duration including any gap until the next segment
+            if i < total_segments - 1:
+                # If there's a next segment, extend until it starts
+                next_segment = segments[i + 1]
+                actual_end_time = next_segment["start"]
+            else:
+                # For the last segment, use its end time
+                actual_end_time = end_time
+            
+            # Calculate total duration including any gap
+            segment_duration = actual_end_time - start_time
+            
+            print(f"\nProcessing segment {i + 1}/{total_segments}:")
+            print(f"  Start time: {start_time}s")
+            print(f"  Base end time: {end_time}s")
+            print(f"  Actual end time: {actual_end_time}s")
+            print(f"  Total duration: {segment_duration}s")
+            print(f"  Text: '{current_segment['text']}'")
+            
+            # Ensure the image index is within bounds
+            image_path = images[min(i, len(images) - 1)]
+            
+            # Create an ImageClip for the current segment
+            image_clip = ImageClip(image_path)
+            
+            # Resize and pad the image to fit a 16:9 aspect ratio
+            image_clip = image_clip.resize(height=frame_height).on_color(
+                size=(frame_width, frame_height),
+                color=(0, 0, 0),  # Black background
+                pos="center"      # Center the image
+            )
+            
+            # Set the duration and start time for the clip
+            image_clip = image_clip.set_duration(segment_duration)
+            image_clip = image_clip.set_start(start_time)  # Set the start time explicitly
+            
+            video_clips.append(image_clip)
+
+        # Concatenate all the image clips to form the video
+        print("Concatenating video clips...")
+        video = concatenate_videoclips(video_clips, method="compose")
+
+        # Add the audio to the video
+        video = video.set_audio(audio)
+
+        # Save the video to a temporary file
+        temp_dir = tempfile.gettempdir()
+        video_path = os.path.join(temp_dir, "generated_video.mp4")
+        print(f"Writing video file to {video_path}...")
+        video.write_videofile(video_path, fps=30, codec="libx264", audio_codec="aac")
+
+        # Clean up the temporary audio file
+        os.remove(temp_audio_path.name)
+        print("Temporary audio file removed.")
+
+        return video_path
+
+    except Exception as e:
+        print(f"Error generating video: {e}")
+        return None
+
+
+
+
+
+
+# Example usage:
+if __name__ == "__main__":
+    short_story = """
+    In a quiet village, a young girl named Lily discovered a hidden garden.
+    Every flower in the garden glowed with a magical light, revealing secrets of the past.
+    Lily knew she had found something truly extraordinary.
+    """
+    generate_audio(short_story, "Urdu", "Asad")
+    # scenes_response = get_scenes(short_story)
+    # scenes = scenes_response.get("scenes")
+    # print("total scenes: ", len(scenes))
+    # for scene in scenes:
+    #     print("image prompts for this scene", len(scene.get("image_prompts")))
+    #     print("\n\n")
+    # for scene_count,scene in enumerate(scenes):
+    #     image_prompts = scene.get("image_prompts")
+    #     for count, prompt in enumerate(image_prompts):
+    #         generate_image(prompt=prompt, path=f"scene_{scene_count+1}_image_{count+1}.png")