Refactor: Integrate setup_config and cleanup asset handling

- Remove hardcoded audio/video lists from
- Update and to use for checks
- Integrate loading into
- Simplify video download logic and remove unused paths

.github/workflows/process_csv.yml

@@ -105,7 +105,6 @@ jobs:
           IS_ONSCREEN_CTA: ${{ vars.IS_ONSCREEN_CTA }}
           DELETE_ALL_A2E_VIDEOS: ${{ vars.DELETE_ALL_A2E_VIDEOS }}
           USE_GEMIMI_VIDEO: ${{ vars.USE_GEMIMI_VIDEO }}
-          ONLY_RANDOM_VIDEOS: ${{ vars.ONLY_RANDOM_VIDEOS }}
           PlAIN_VIDEO_COUNT: ${{ vars.PlAIN_VIDEO_COUNT }}
           USE_1X1_RATIO: ${{ vars.USE_1X1_RATIO }}
           ON_SCREEN_TEXT: ${{ vars.ON_SCREEN_TEXT }}

setup/beats_cut/config.toml

@@ -0,0 +1,16 @@
+# Beats Cut Random Videos Setup
+# Uses beat detection to sync video cuts with music
+
+[general]
+setup_type = "beats_cut"
+description = "Random videos with cuts synced to music beats"
+
+[video]
+beat_method = "downbeat"
+
+[gsheet]
+name = "Infloxa Data for Elvoro"
+id = "1djnE1u_QCveGlhjNnZRfXiY-3NLzO0V-04tZ9P2mVcs"
+video_library_worksheet = "Video Library"
+audio_library_worksheet = "Audio Library"
+logs_worksheet = "Infloxa Data for Elvoro LOGS"

setup/hard_cut/config.toml

@@ -0,0 +1,16 @@
+# Hard Cut Random Videos Setup
+# Uses fixed intervals instead of beat detection for video cuts
+
+[general]
+setup_type = "hard_cut"
+description = "Random videos with hard cuts at fixed intervals"
+
+[video]
+hard_cut_random_videos_interval = "0.5"
+
+[gsheet]
+name = "Infloxa Data for Elvoro"
+id = "1djnE1u_QCveGlhjNnZRfXiY-3NLzO0V-04tZ9P2mVcs"
+video_library_worksheet = "Video Library"
+audio_library_worksheet = "Audio Library"
+logs_worksheet = "Infloxa Data for Elvoro LOGS"

setup/setup_4_no_ai_video/README.md

@@ -25,13 +25,6 @@ CSV file containing content strategy entries.
   ```
 - Full path: `data/content_strategies_on_screen_text.csv`
 
-#### **ONLY_RANDOM_VIDEOS**
-Enables random library clip selection (bypasses metadata-driven selection).
-
-```
-ONLY_RANDOM_VIDEOS=true
-```
-
 #### **BEAT_METHOD**
 Controls beat-sync behavior.
 

src/api_clients.py

@@ -867,7 +867,7 @@ class APIClients:
         """
         try:
             if os.getenv("TEST_AUTOMATION", "").lower() == "true":
-                return f"{os.getenv('TEST_DATA_DIRECTORY')}/final_video_Ifeltexh_1762093574_compressed.mp4"
+                return f"{os.getenv('TEST_DATA_DIRECTORY')}/{uuid.uuid4().hex}.mp4"
 
             # Prepare a safe pattern to search by
             safe_name_10 = "".join(c for c in tts_script[:10] if c.isalnum())

src/asset_selector.py

@@ -12,6 +12,7 @@ from data_holder import DataHolder
 import gemini_sdk
 from google_sheet_reader import GoogleSheetReader
 from google_src import GCloudWrapper, GCloudAccount, get_default_wrapper
+import setup_config
 
 
 class AssetSelector:
@@ -40,37 +41,6 @@ class AssetSelector:
         self.current_audio_index = (self.current_audio_index + 1) % len(self.audio_library)
         self.config["current_audio_index"] = self.current_audio_index
 
-    def _load_video_library(self) -> pd.DataFrame:
-        """Load video library from specific CSV file"""
-        try:
-            if os.getenv("INFLOXA", "false").lower() == "true":
-                csv_filename = "data/infloxa_video_library100.csv"
-            elif os.getenv("USE_VEO", "false").lower() == "true":
-                csv_filename = "data/somira_video_library_veo.csv"
-            else:
-                csv_filename = "data/somira_video_library.csv"
-
-            if not os.path.exists(csv_filename):
-                logger.error(f"CSV file not found: {csv_filename}")
-                return pd.DataFrame()
-
-            df = pd.read_csv(csv_filename)
-
-            if "Energy Score (0-100)" in df.columns:
-                df["energy_score"] = df["Energy Score (0-100)"].apply(self._parse_energy_score)
-
-            if "Duration" in df.columns:
-                df["duration"] = df["Duration"].apply(self._parse_duration)
-            elif "duration" in df.columns:
-                df["duration"] = df["duration"].apply(self._parse_duration)
-
-            logger.info(f"Successfully loaded video library with {len(df)} entries")
-            return df
-
-        except Exception as e:
-            logger.error(f"Failed to load video library from CSV: {e}")
-            raise
-
     def _parse_duration(self, duration_str: str) -> int:
         """Parse duration from various string formats to integer seconds"""
         try:
@@ -87,30 +57,6 @@ class AssetSelector:
             logger.warning(f"Failed to parse duration '{duration_str}': {e}")
             return 0
 
-    def _load_audio_library(self) -> List[str]:
-        """Load audio library URLs"""
-        audios = [f"https://storage.googleapis.com/somira/{i}.mp3" for i in range(1, 27)]
-        for adio in [
-            "https://storage.googleapis.com/somira/ssstik.io_1762269951926.mp3",
-            "https://storage.googleapis.com/somira/Runaway_musicaldown.com_1762637229.mp3",
-            "https://storage.googleapis.com/somira/Relaxed%20(Sped%20Up)_musicaldown.com_1762641321.mp3",
-            "https://storage.googleapis.com/somira/original%20sound%20-%20vienna.visitas_musicaldown.com_1762639795.mp3",
-            "https://storage.googleapis.com/somira/original%20sound%20-%20lxuissoundz_musicaldown.com_1762636022.mp3",
-            "https://storage.googleapis.com/somira/LUNA%20BALA%20(Slowed)_musicaldown.com_1762637032.mp3",
-            "https://storage.googleapis.com/somira/Funny_musicaldown.com_1762641235.mp3",
-            "https://storage.googleapis.com/somira/7AM%20-%20Slowed%20%2B%20Reverb_musicaldown.com_1762638022.mp3",
-            "https://storage.googleapis.com/somira/original%20sound%20-%20yzwlk_musicaldown.com_1762641762.mp3"
-        ]:
-            audios.append(adio)
-
-        if os.getenv("SETUP_TYPE", "").lower() == "onlyrandomvideo_onscreen_text":
-            audios.remove("https://storage.googleapis.com/somira/23.mp3")
-            audios.remove("https://storage.googleapis.com/somira/ssstik.io_1762269951926.mp3")
-
-        if os.getenv("INFLOXA", "false").lower() == "true":
-            audios = ["testData/infloxa/audiopulse.mp3"]
-        return audios
-
     def get_audio_beats(self, audio_link: str) -> Optional[List[float]]:
         """
         Load audio beats timing from audio_library and convert
@@ -181,7 +127,7 @@ class AssetSelector:
                 account_id=account_id,
             )
             audio_df = googleSheetReader.get_filtered_dataframe()
-            if os.getenv("HARD_CUT_RANDOM_VIDEOS", "false").lower() == "false":
+            if setup_config.get_str("setup_type") == "beats_cut":
                 audio_df = utils.clean_and_drop_empty(audio_df, "Beats Timing(SS:FF) AT 25FPS")
             return utils.clean_and_drop_empty(audio_df, "AUDIO_LINK")
         except Exception as e:

src/automation.py

@@ -26,6 +26,7 @@ import math
 import numpy as np
 from file_downloader import FileDownloader
 from data_holder import DataHolder
+import setup_config
 
 class ContentAutomation:
     def __init__(self, config: Dict[str, Any], data_holder: DataHolder = None, asset_selector: 'AssetSelector' = None, api_clients: 'APIClients' = None):
@@ -53,7 +54,7 @@ class ContentAutomation:
             logger.info("\n🎭 STEP 1: Clean TTS Script")
             self.data_holder.tts_script = utils.clean_tts_script(tts_script)
 
-            if os.getenv("ONLY_RANDOM_VIDEOS", "false").lower() == "true":
+            if setup_config.get_str("setup_type") in ["beats_cut", "hard_cut"]:
                 return await self.execute_random_pipeline(content_strategy, tts_script)
 
             prompt_refer = content_strategy.get("gemini_prompt", "")
@@ -199,14 +200,12 @@ class ContentAutomation:
         try:
             await self._download_all_video()
 
-            music_duration = 10
-            if os.getenv("INFLOXA", "false").lower() == "true":
-                music_duration = 15
+            music_duration = None
 
             beat_times = None
             try_next = False
-            hard_cut_mode = os.getenv("HARD_CUT_RANDOM_VIDEOS", "false").lower() == "true"
-            hard_cut_mode_interval = os.getenv("HARD_CUT_RANDOM_VIDEOS_INTERVAL", "0.5")
+            hard_cut_mode = setup_config.get_str("setup_type") == "hard_cut"
+            hard_cut_mode_interval = setup_config.get_str("hard_cut_random_videos_interval", "0.5")
 
             if hard_cut_mode:
                 # No beat detection needed, just download music once
@@ -269,7 +268,7 @@ class ContentAutomation:
                 logger.info(f"[{idx}/{total}] Done")
 
 
-            if os.getenv("HARD_CUT_RANDOM_VIDEOS", "false").lower() == "true":
+            if setup_config.get_str("setup_type") == "hard_cut":
                 # IMPORTANT: Pass filtered_beat_times, not beat_intervals!
                 video_no_audio_path = await self.video_renderer.render_interval_video(
                     float(hard_cut_mode_interval),
@@ -354,10 +353,6 @@ class ContentAutomation:
         await self._download_to_local(
             self.data_holder.visual_assets["background_music_url"], "background_music.mp3", self.data_holder.visual_assets, "background_music_local"
         )
-        # if os.getenv("INFLOXA", "false").lower() == "true":
-        #     output_path = "/tmp/repeated_bg_music.mp3"
-        #     output_path = utils.repeat_audio_ffmpeg(self.data_holder.visual_assets["background_music_local"], output_path, 5)
-        #     self.data_holder.visual_assets["background_music_local"] = output_path
 
     async def create_audio(self):
         try_again = False
@@ -406,37 +401,33 @@ class ContentAutomation:
             logger.info("✅ All videos already have local_path — skipping download.")
             return
 
-        if os.getenv("INFLOXA", "false").lower() == "true":
-            download_path="testData/infloxa"
-            Path(download_path).mkdir(parents=True, exist_ok=True)
+        download_path = "testData/video_for_workflow"
+        Path(download_path).mkdir(parents=True, exist_ok=True)
 
-            allowed_videos = []
-
-            videos = [
-                {
-                    "url": url,
-                    "local_path": str(local_path),
-                }
-                for _, row in self.asset_selector.video_library.iterrows()
-                if (
-                    (url := str(row.get("VIDEO_LINK", "")).strip())
-                    and (local_path := self.file_downloader.safe_download(url=url))
-                    and utils.is_valid_video(local_path)
-                )
-            ]
-            self.data_holder.visual_assets["all_videos"] = videos
-
-        else:
-            self.data_holder.visual_assets["all_videos"] = [
-                {"url": row.get("Video URL (No Audio)", "").strip()}
-                for _, row in self.asset_selector.video_library.iterrows()
-                if row.get("Video URL (No Audio)", "").strip()
-            ]
-
-            # ⬇️ Download them
-            logger.info(f"📥 Downloading {len(self.data_holder.visual_assets['all_videos'])} videos...")
-            await self._download_all_visual_assets()
-            logger.info("✅ All videos downloaded successfully")
+        videos = []
+        for _, row in self.asset_selector.video_library.iterrows():
+            url = str(row.get("VIDEO_LINK", "")).strip()
+            if not url:
+                continue
+            
+            local_path = self.file_downloader.safe_download(url=url)
+            if not local_path or not utils.is_valid_video(local_path):
+                continue
+            
+            # Resize and remove padding (handle potential errors)
+            try:
+                utils.resize_video(local_path, overwrite=True)
+                utils.remove_black_padding(local_path, overwrite=True)
+            except Exception as e:
+                logger.warning(f"⚠️ Could not process {local_path}: {e}")
+                # Continue anyway - video is still usable
+            
+            videos.append({
+                "url": url,
+                "local_path": str(local_path),
+            })
+        
+        self.data_holder.visual_assets["all_videos"] = videos
 
     async def _generate_visual_assets_parallel(self, content_strategy: Dict) -> Dict:
         """Generate visual assets in parallel (hook video + library videos)"""

src/load_config.py

@@ -131,12 +131,23 @@ def load_configuration() -> Dict:
             logger.debug(f"Could not load from gcloud config: {e}")
 
     # Build configuration dictionary
+    # Start with setup config from TOML if available
+    try:
+        from setup_config import load_setup_config
+        setup_config = load_setup_config()
+        logger.info(f"✓ Loaded setup config: {setup_config.get('setup_type', 'unknown')}")
+    except (ValueError, FileNotFoundError, ImportError) as e:
+        logger.debug(f"Setup config not loaded (optional): {e}")
+        setup_config = {}
+    
+    # Merge setup config with secrets from environment
     config = {
+        **setup_config,  # TOML config values (can be overridden below)
         "gemini_api_key": os.getenv("GEMINI_API_KEY"),
         "runwayml_api_key": os.getenv("RUNWAYML_API_KEY"),
         "gcs_bucket_name": os.getenv("GCS_BUCKET_NAME"),
         "gcp_project_id": gcp_project_id,
-        "default_voice": os.getenv("DEFAULT_VOICE", "en-US-Neural2-F"),
+        "default_voice": setup_config.get("voice") or os.getenv("DEFAULT_VOICE", "en-US-Neural2-F"),
         "auth_method": auth_method,  # Track how project was loaded
     }
 

src/onscreebcta.py

@@ -309,9 +309,9 @@ def create_cta_on_strip(
 
 def add_cta(input_video_path: str, cta_text: str, above_caption: bool = True, padding: int = 20, show_strip: bool = False, bottom_safe_y: int = None) -> str:
     if above_caption:
-        output_video_path = f"/tmp/{uuid.uuid4().hex[:8]}final_video_above_caption.mp4"
+        output_video_path = f"/tmp/{uuid.uuid4().hex[:8]}_above_caption.mp4"
     else:
-        output_video_path = f"/tmp/{uuid.uuid4().hex[:8]}final_video_below_caption.mp4"
+        output_video_path = f"/tmp/{uuid.uuid4().hex[:8]}_below_caption.mp4"
 
     logger.info(f"Loading video: '{input_video_path}'...")
     base_video = VideoFileClip(input_video_path)

src/process_csv.py

@@ -18,6 +18,7 @@ import argparse
 import uuid
 from cleanup_manager import process_delete_entries
 from google_src.gcs_utils import list_gcs_files
+import setup_config
 
 DATA_DIR = Path("data")
 ALL_VIDEO_FILE_INFO = None
@@ -391,7 +392,7 @@ Examples:
         os.environ.pop("VERTEX_AI_CREDENTIALS_JSON", None)
 
     await download_all_video(config)
-    if os.getenv("ON_SCREEN_TEXT", "false").lower() != "true" and os.getenv("ONLY_RANDOM_VIDEOS", "false").lower() == "true":
+    if os.getenv("ON_SCREEN_TEXT", "false").lower() != "true" and setup_config.get_str("setup_type") in ["beats_cut", "hard_cut"]:
         await create_plain_videos(config, commit=args.commit, job_index=job_index, total_jobs=total_jobs)
     else:
         await process_all_csvs(config, commit=args.commit, job_index=job_index, total_jobs=total_jobs)

src/setup_config.py

@@ -0,0 +1,275 @@
+"""
+Setup Configuration Loader
+
+Loads TOML configuration from setup/<setup_name>/config.toml files.
+This allows different setups to be selected via SETUP_NAME env var,
+keeping secrets in .env and config in version-controlled TOML files.
+"""
+
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Use standalone logger to avoid heavy imports from utils
+logger = logging.getLogger(__name__)
+
+# Use tomllib (Python 3.11+) or fall back to tomli
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+
+# Cached config singleton
+_cached_config: Optional[Dict[str, Any]] = None
+_cached_setup_name: Optional[str] = None
+
+
+def get_setup_dir() -> Path:
+    """Get the setup directory path."""
+    # Go from src/ to project root, then into setup/
+    project_root = Path(__file__).parent.parent
+    return project_root / "setup"
+
+
+def list_available_setups() -> list[str]:
+    """List all available setup configurations."""
+    setup_dir = get_setup_dir()
+    setups = []
+    
+    if setup_dir.exists():
+        for item in setup_dir.iterdir():
+            if item.is_dir() and (item / "config.toml").exists():
+                setups.append(item.name)
+    
+    return sorted(setups)
+
+
+def load_setup_config(setup_name: Optional[str] = None, force_reload: bool = False) -> Dict[str, Any]:
+    """
+    Load configuration from setup/<setup_name>/config.toml.
+    
+    Args:
+        setup_name: Name of the setup folder. If None, uses SETUP_NAME env var.
+        force_reload: If True, bypass cache and reload from file.
+    
+    Returns:
+        Dictionary with flattened config values, with env var overrides applied.
+    
+    Raises:
+        ValueError: If setup_name is not provided and SETUP_NAME env var is not set.
+        FileNotFoundError: If the config.toml file doesn't exist.
+    """
+    global _cached_config, _cached_setup_name
+    
+    # Use env var if setup_name not provided
+    if setup_name is None:
+        setup_name = os.getenv("SETUP_NAME")
+    
+    if not setup_name:
+        available = list_available_setups()
+        raise ValueError(
+            f"SETUP_NAME environment variable not set. "
+            f"Available setups: {', '.join(available) if available else 'none found'}"
+        )
+    
+    # Return cached config if same setup and not forcing reload
+    if not force_reload and _cached_config is not None and _cached_setup_name == setup_name:
+        return _cached_config
+    
+    # Check if tomllib is available
+    if tomllib is None:
+        raise ImportError(
+            "TOML parsing requires Python 3.11+ or the 'tomli' package. "
+            "Install with: pip install tomli"
+        )
+    
+    # Load the TOML file
+    setup_dir = get_setup_dir()
+    config_path = setup_dir / setup_name / "config.toml"
+    
+    if not config_path.exists():
+        available = list_available_setups()
+        raise FileNotFoundError(
+            f"Config file not found: {config_path}\n"
+            f"Available setups: {', '.join(available) if available else 'none found'}"
+        )
+    
+    logger.info(f"Loading setup config from: {config_path}")
+    
+    with open(config_path, "rb") as f:
+        raw_config = tomllib.load(f)
+    
+    # Flatten the config and apply env var overrides
+    config = _flatten_config(raw_config)
+    config = _apply_env_overrides(config)
+    
+    # Cache the result
+    _cached_config = config
+    _cached_setup_name = setup_name
+    
+    logger.info(f"✓ Loaded setup config: {setup_name} ({len(config)} settings)")
+    
+    return config
+
+
+def _flatten_config(config: Dict[str, Any], prefix: str = "") -> Dict[str, Any]:
+    """
+    Flatten nested TOML config into a flat dictionary.
+    
+    Example:
+        {"video": {"only_random_videos": true}} 
+        -> {"video.only_random_videos": true, "only_random_videos": true}
+    
+    Both nested key and flat key are provided for flexibility.
+    """
+    result = {}
+    
+    for key, value in config.items():
+        full_key = f"{prefix}.{key}" if prefix else key
+        
+        if isinstance(value, dict):
+            # Recurse into nested dicts
+            nested = _flatten_config(value, full_key)
+            result.update(nested)
+        else:
+            # Add both the full nested key and the simple key
+            result[full_key] = value
+            # Also add simple key if it doesn't conflict
+            if key not in result:
+                result[key] = value
+    
+    return result
+
+
+def _apply_env_overrides(config: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Apply environment variable overrides to config values.
+    
+    Env var names are mapped from config keys:
+        only_random_videos -> ONLY_RANDOM_VIDEOS
+        video.hard_cut_random_videos -> HARD_CUT_RANDOM_VIDEOS
+    """
+    result = config.copy()
+    
+    # Map of config keys to env var names
+    env_mappings = {
+        "only_random_videos": "ONLY_RANDOM_VIDEOS",
+        "hard_cut_random_videos": "HARD_CUT_RANDOM_VIDEOS",
+        "use_veo": "USE_VEO",
+        "beat_method": "BEAT_METHOD",
+        "setup_type": "SETUP_TYPE",
+        "caption_style": "CAPTION_STYLE",
+        "content_strategy_file": "CONTENT_STRATEGY_FILE",
+        "on_screen_text": "ON_SCREEN_TEXT",
+        "is_onscreen_cta": "IS_ONSCREEN_CTA",
+        "is_a2e_lip_sync": "IS_A2E_LIP_SYNC",
+        "use_1x1_ratio": "USE_1X1_RATIO",
+        "audio_library_size": "AUDIO_LIBRARY_SIZE",
+        "video_library_size": "VIDEO_LIBRARY_SIZE",
+        "debug_mode": "DEBUG_MODE",
+        "video_quality": "VIDEO_QUALITY",
+        "voice": "DEFAULT_VOICE",
+        "video_generation_timeout": "VIDEO_GENERATION_TIMEOUT",
+        "max_concurrent_requests": "MAX_CONCURRENT_REQUESTS",
+        "max_retry_attempts": "MAX_RETRY_ATTEMPTS",
+        "output_directory": "OUTPUT_DIRECTORY",
+        "temp_directory": "TEMP_DIRECTORY",
+        # GSheet mappings
+        "gsheet.name": "GSHEET_NAME",
+        "gsheet.id": "GSHEET_ID",
+        "video_library_worksheet": "VIDEO_LIBRARY_GSHEET_WORKSHEET",
+        "audio_library_worksheet": "AUDIO_LIBRARY_GSHEET_WORKSHEET",
+        "logs_worksheet": "GSHEET_WORKSHEET_LOGS",
+    }
+    
+    for config_key, env_var in env_mappings.items():
+        env_value = os.getenv(env_var)
+        if env_value is not None:
+            # Convert to appropriate type based on existing config value
+            if config_key in result:
+                original_type = type(result[config_key])
+                if original_type == bool:
+                    result[config_key] = env_value.lower() in ("true", "1", "yes")
+                elif original_type == int:
+                    try:
+                        result[config_key] = int(env_value)
+                    except ValueError:
+                        pass
+                else:
+                    result[config_key] = env_value
+            else:
+                result[config_key] = env_value
+    
+    return result
+
+
+def get_config_value(key: str, default: Any = None) -> Any:
+    """
+    Get a single config value by key.
+    
+    Args:
+        key: Config key (e.g., "only_random_videos" or "video.only_random_videos")
+        default: Default value if key not found
+    
+    Returns:
+        Config value or default
+    """
+    config = load_setup_config()
+    return config.get(key, default)
+
+
+def get_bool(key: str, default: bool = False) -> bool:
+    """Get a boolean config value."""
+    value = get_config_value(key, default)
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() in ("true", "1", "yes")
+    return bool(value)
+
+
+def get_int(key: str, default: int = 0) -> int:
+    """Get an integer config value."""
+    value = get_config_value(key, default)
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return default
+
+
+def get_str(key: str, default: str = "") -> str:
+    """Get a string config value."""
+    value = get_config_value(key, default)
+    return str(value) if value is not None else default
+
+
+# Convenience function for common pattern
+def is_enabled(key: str) -> bool:
+    """Check if a feature flag is enabled."""
+    return get_bool(key, False)
+
+
+# ------------------ CLI Usage ------------------
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+    load_dotenv()
+    
+    print("\n=== Available Setups ===")
+    for setup in list_available_setups():
+        print(f"  - {setup}")
+    
+    print("\n=== Loading Config ===")
+    try:
+        config = load_setup_config()
+        print(f"\nLoaded config ({len(config)} keys):")
+        for key, value in sorted(config.items()):
+            print(f"  {key}: {value}")
+    except (ValueError, FileNotFoundError) as e:
+        print(f"\nError: {e}")

src/video_downloader.py

@@ -670,13 +670,13 @@ if __name__ == "__main__":
         load_dotenv()
 
         downloader = VideoDownloader()
-        downloader._init_drive_downloader(download_path="testData/infloxa")
+        downloader._init_drive_downloader(download_path="testData/video_for_workflow")
         add_link_column("testData/infloxa_copy/videos.csv", "testData/infloxa_copy/videos_with_links.csv", downloader)
         
         # Download from Drive folder link
         # result = downloader.download_from_drive_link(
         #     drive_link="https://drive.google.com/drive/folders/1WSrVAyqvPJzpRnoUxkNx0LqK9VlDs432",
-        #     download_root="testData/infloxa",
+        #     download_root="testData/video_for_workflow",
         #     file_extensions=['.mp4', '.mov', '.avi', '.mkv']  # Only video files
         # )
         

src/video_renderer.py

@@ -986,8 +986,7 @@ class VideoRenderer:
     async def render_video_final(self, video_clip) -> str:
         """Render final video clip to file"""
         try:
-            safe_name = "".join(c for c in self.data_holder.tts_script[:50] if c.isalnum())
-            output_path = self.temp_dir / f"{os.getenv('SETUP_TYPE', 'final_video')}_{safe_name}_{int(time.time())}.mp4"
+            output_path = self.temp_dir / f"{uuid.uuid4().hex}.mp4"
 
             video_clip.write_videofile(str(output_path), codec="libx264", audio_codec="aac", fps=25, verbose=False, logger=None)
 

video_analyser/config.yaml

@@ -22,7 +22,7 @@ processing:
   
 # Output Settings
 output:
-  local_video_dir: "infloxa"  # Relative to video_analyser/
+  local_video_dir: "video_for_workflow"  # Relative to video_analyser/
   csv_file: "infloxa_video_analysis.csv"  # Relative to video_analyser/
   
 # Scoring Weights (must sum to 1.0)