Refactor: Unify configuration management and replace legacy content strategy loading

- Unified config into src/config.py
- Removed legacy load_config.py and setup_config.py
- Updated consumers to use src/config.py
- Refactored publishers to use ContentStrategyLib instead of local CSVs
- Cleaned up imports in a2e_avatar.py

requirements.txt

@@ -16,6 +16,7 @@ google-api-python-client==2.184.0
 google-auth-oauthlib==1.2.3
 librosa==0.11.0
 gspread
+tomllib
 
 # aiosignal==1.4.0
 # annotated-types==0.7.0

src/a2e_avatar.py

@@ -13,7 +13,7 @@ from google_src import ai_studio_sdk
 import json_repair
 from data_holder import DataHolder
 from moviepy.editor import AudioFileClip
-from api_clients import APIClients
+
 import uuid
 import json
 

src/asset_manager/audio_lib.py

@@ -10,9 +10,7 @@ from typing import Optional, List
 from utils import logger, clean_and_drop_empty
 from google_src.google_sheet import GoogleSheetReader
 from google_src import get_default_wrapper, GCloudWrapper
-import setup_config
-
-
+from config import get_str
 class AudioLib:
     """
     Singleton class that loads and manages audio library from Google Sheets.
@@ -72,7 +70,7 @@ class AudioLib:
             audio_df = googleSheetReader.get_filtered_dataframe()
             
             # Filter by beats timing if in beats_cut mode
-            if setup_config.get_str("setup_type") == "beats_cut":
+            if get_str("setup_type") == "beats_cut":
                 audio_df = clean_and_drop_empty(audio_df, "Beats Timing(SS:FF) AT 25FPS")
             
             return clean_and_drop_empty(audio_df, "AUDIO_LINK")

src/automation.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from video_renderer import VideoRenderer
 from utils import logger
 import utils
+from config import get_str
 from moviepy.config import change_settings
 from moviepy.config import change_settings
 from google_src.gcs_utils import upload_file_to_gcs
@@ -30,7 +31,7 @@ import math
 import numpy as np
 from file_downloader import FileDownloader
 from data_holder import DataHolder
-import setup_config
+
 from asset_manager import get_asset_downloader, get_audio_lib, AssetProcessor
 from file_downloader import FileDownloader
 
@@ -65,7 +66,7 @@ class ContentAutomation:
             logger.info("\n🎭 STEP 1: Clean TTS Script")
             self.data_holder.tts_script = utils.clean_tts_script(tts_script)
 
-            if setup_config.get_str("setup_type") in ["beats_cut", "hard_cut"]:
+            if 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", "")
@@ -221,8 +222,8 @@ class ContentAutomation:
 
             beat_times = None
             try_next = False
-            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")
+            hard_cut_mode = get_str("setup_type") == "hard_cut"
+            hard_cut_mode_interval = get_str("hard_cut_random_videos_interval", "0.5")
 
             if hard_cut_mode:
                 # No beat detection needed, just download music once
@@ -283,7 +284,7 @@ class ContentAutomation:
                 logger.info(f"[{idx}/{total}] Done")
 
 
-            if setup_config.get_str("setup_type") == "hard_cut":
+            if 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),

src/{setup_config.py → config.py}

@@ -1,18 +1,22 @@
 """
-Setup Configuration Loader
+Unified Configuration Module
 
-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.
+Combines functionality from load_config.py and setup_config.py to provide
+a single source of truth for application configuration.
 """
 
-import logging
 import os
 import sys
+import json
+import logging
 from pathlib import Path
 from typing import Dict, Any, Optional
 
-# Use standalone logger to avoid heavy imports from utils
+from dotenv import load_dotenv
+from google.auth import default
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Use tomllib (Python 3.11+) or fall back to tomli
@@ -24,11 +28,13 @@ else:
     except ImportError:
         tomllib = None
 
+# ------------------ Singleton & Cache ------------------
 
-# Cached config singleton
 _cached_config: Optional[Dict[str, Any]] = None
 _cached_setup_name: Optional[str] = None
+_config_initialized: bool = False
 
+# ------------------ Setup Config Logic ------------------
 
 def get_setup_dir() -> Path:
     """Get the setup directory path."""
@@ -50,83 +56,9 @@ def list_available_setups() -> list[str]:
     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 = {}
     
@@ -150,10 +82,6 @@ def _flatten_config(config: Dict[str, Any], prefix: str = "") -> Dict[str, Any]:
 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()
     
@@ -209,67 +137,277 @@ def _apply_env_overrides(config: Dict[str, Any]) -> Dict[str, Any]:
     return result
 
 
-def get_config_value(key: str, default: Any = None) -> Any:
+def _load_setup_config_data(setup_name: Optional[str] = None) -> Dict[str, Any]:
+    """Helper to load and process the TOML configuration file."""
+    if setup_name is None:
+        setup_name = os.getenv("SETUP_NAME")
+    
+    if not setup_name:
+        # If no setup name is provided or in env, return empty or raise?
+        # Preserving logic from setup_config.py which raised an error only if strictly required
+        # But here we want to handle the case where it might be missing gracefully if usage allows
+        return {}
+
+    setup_dir = get_setup_dir()
+    config_path = setup_dir / setup_name / "config.toml"
+    
+    if not config_path.exists():
+        # Fallback or error handled by caller/validator
+        return {}
+    
+    if tomllib is None:
+         logger.warning("TOML supported needed but not available. Install 'tomli' for Python < 3.11")
+         return {}
+
+    try:
+        with open(config_path, "rb") as f:
+            raw_config = tomllib.load(f)
+        
+        flat_config = _flatten_config(raw_config)
+        return _apply_env_overrides(flat_config)
+    except Exception as e:
+        logger.error(f"Error loading setup config: {e}")
+        return {}
+
+
+# ------------------ GCP Auth Configuration ------------------
+
+def _resolve_gcp_project_id() -> tuple[Optional[str], Optional[str]]:
+    """
+    Resolve GCP Project ID and auth method.
+    Returns (project_id, auth_method)
     """
-    Get a single config value by key.
+    gcp_project_id = None
+    auth_method = None
     
-    Args:
-        key: Config key (e.g., "only_random_videos" or "video.only_random_videos")
-        default: Default value if key not found
+    # 1. Service Account JSON (CI/CD)
+    gcp_creds_path = (os.getenv("GOOGLE_GHA_CREDS_PATH") or 
+                      os.getenv("CLOUDSDK_AUTH_CREDENTIAL_FILE_OVERRIDE") or 
+                      os.getenv("GOOGLE_APPLICATION_CREDENTIALS"))
+
+    if gcp_creds_path:
+        # Set temp bucket env var side-effect (from original load_config)
+        os.environ["MY_TEMP_GCS_BUCKET"] = os.getenv("MY_TEMP_GCS_BUCKET", "")
+        
+        try:
+            if Path(gcp_creds_path).exists():
+                logger.info(f"Loading GCP credentials from file: {gcp_creds_path}")
+                with open(gcp_creds_path, "r") as f:
+                    creds_data = json.load(f)
+                gcp_project_id = creds_data.get("project_id")
+                auth_method = "service_account_file"
+            else:
+                try:
+                    creds_data = json.loads(gcp_creds_path)
+                    gcp_project_id = creds_data.get("project_id")
+                    auth_method = "service_account_json"
+                except json.JSONDecodeError:
+                    pass
+        except Exception as e:
+           logger.warning(f"Error processing GCP credentials path: {e}")
+
+    # 2. Workload Identity Federation / ADC
+    if not gcp_project_id:
+        try:
+            # This handles both WIF and ADC
+            creds, project = default()
+            if project:
+                gcp_project_id = project
+                if os.getenv("WORKLOAD_IDENTITY_PROVIDER"):
+                    auth_method = "workload_identity_federation"
+                else:
+                    auth_method = "adc"
+        except Exception:
+            pass
+
+    # 3. Environment Variables
+    if not gcp_project_id:
+         gcp_project_id = (
+            os.getenv("GOOGLE_CLOUD_PROJECT") or
+            os.getenv("GCP_PROJECT") or
+            os.getenv("GCLOUD_PROJECT") or
+            os.getenv("CLOUDSDK_CORE_PROJECT") or
+            os.getenv("CLOUDSDK_PROJECT") or
+            os.getenv("GCP_PROJECT_ID")
+        )
+         if gcp_project_id:
+             auth_method = "environment_variable"
+
+    # 4. GCloud Config
+    if not gcp_project_id:
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["gcloud", "config", "get-value", "project"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0:
+                pid = result.stdout.strip()
+                if pid and pid != "(unset)":
+                    gcp_project_id = pid
+                    auth_method = "gcloud_config"
+        except Exception:
+            pass
+            
+    return gcp_project_id, auth_method
+
+
+# ------------------ Main Load Function ------------------
+
+def load_configuration(force_reload: bool = False) -> Dict[str, Any]:
+    """
+    Load configuration from all sources.
     
-    Returns:
-        Config value or default
+    1. Load .env
+    2. Load Setup Config (TOML)
+    3. Resolve GCP Project & Secrets
+    4. Merge & Validate
     """
-    config = load_setup_config()
+    global _cached_config, _cached_setup_name, _config_initialized
+
+    setup_name = os.getenv("SETUP_NAME")
+    
+    # Return cache if valid
+    if (_config_initialized and not force_reload and 
+        _cached_config is not None and 
+        _cached_setup_name == setup_name):
+        return _cached_config
+
+    load_dotenv()
+    
+    # Load Setup Config (TOML)
+    # Note: We don't fail hard here if SETUP_NAME is missing, we just get empty setup config
+    # Validation happens later if critical keys are missing.
+    setup_config = _load_setup_config_data(setup_name)
+    if setup_config:
+         logger.info(f"✓ Loaded setup config: {setup_name}")
+    
+    # Resolve GCP Project
+    gcp_project_id, auth_method = _resolve_gcp_project_id()
+    if gcp_project_id:
+        logger.info(f"✓ GCP Project ID: {gcp_project_id} ({auth_method})")
+    
+    # Merge into final config
+    config = {
+        **setup_config,
+        "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": setup_config.get("voice") or os.getenv("DEFAULT_VOICE", "en-US-Neural2-F"),
+        "auth_method": auth_method,
+        "setup_name": setup_name,
+    }
+    
+    # Required keys validation (soft validation - log error but don't crash module import)
+    # Crashes should handle at application start
+    _cached_config = config
+    _cached_setup_name = setup_name
+    _config_initialized = True
+    
+    return config
+
+
+# ------------------ Public API ------------------
+
+class ConfigProxy:
+    """
+    Singleton proxy to access configuration.
+    Lazily loads config on first access.
+    """
+    def __init__(self):
+        self._config = None
+        
+    def _ensure_loaded(self):
+        if self._config is None:
+            self._config = load_configuration()
+            
+    def get(self, key: str, default: Any = None) -> Any:
+        self._ensure_loaded()
+        return self._config.get(key, default)
+    
+    def __getitem__(self, key: str) -> Any:
+        self._ensure_loaded()
+        return self._config[key]
+        
+    def __contains__(self, key: str) -> bool:
+        self._ensure_loaded()
+        return key in self._config
+
+    def items(self):
+         self._ensure_loaded()
+         return self._config.items()
+
+    def set(self, key: str, value: Any):
+        """Set a configuration value."""
+        self._ensure_loaded()
+        self._config[key] = value
+
+    def __setitem__(self, key: str, value: Any):
+        self._ensure_loaded()
+        self._config[key] = value
+         
+    def reload(self):
+        self._config = load_configuration(force_reload=True)
+
+# Global singleton
+config = ConfigProxy()
+
+
+def get_config_value(key: str, default: Any = None) -> Any:
     return config.get(key, default)
 
+def set_config_value(key: str, value: Any):
+    """Set a config value."""
+    config.set(key, value)
 
 def get_bool(key: str, default: bool = False) -> bool:
-    """Get a boolean config value."""
-    value = get_config_value(key, default)
+    value = config.get(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)
+    value = config.get(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)
+    value = config.get(key, default)
     return str(value) if value is not None else default
 
+def set_str(key: str, value: str):
+    """Set a string config value."""
+    config.set(key, str(value))
 
-# Convenience function for common pattern
-def is_enabled(key: str) -> bool:
-    """Check if a feature flag is enabled."""
-    return get_bool(key, False)
 
+def get_gcp_project_id() -> Optional[str]:
+    return config.get("gcp_project_id")
 
-# ------------------ CLI Usage ------------------
+# ------------------ CLI Test ------------------
 
 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 ===")
+    print("\n=== Unified Config Test ===\n")
     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}")
+        conf = load_configuration()
+        print("Configuration Loaded Successfully!")
+        print(f"Setup Name: {conf.get('setup_name')}")
+        print(f"Project ID: {conf.get('gcp_project_id')}")
+        
+        # Check required keys
+        required = ["gemini_api_key", "runwayml_api_key", "gcs_bucket_name", "gcp_project_id"]
+        missing = [k for k in required if not conf.get(k)]
+        
+        if missing:
+             print(f"\n[WARNING] Missing keys: {missing}")
+        else:
+             print("\nAll required keys present.")
+             
+    except Exception as e:
+        print(f"\n[ERROR] {e}")

src/load_config.py

@@ -1,225 +0,0 @@
-import os
-import json
-from pathlib import Path
-from typing import Dict
-
-from dotenv import load_dotenv
-from google.auth import default
-
-from utils import logger
-
-
-def load_configuration() -> Dict:
-    """
-    Load configuration from environment variables with validation.
-    
-    Supports two authentication methods:
-    1. Service Account JSON (CI/CD): Extracts project ID from JSON file or string
-    2. Application Default Credentials (Local): Uses ADC and gcloud config
-    """
-    load_dotenv()
-
-    gcp_project_id = None
-    creds_data = None
-    auth_method = None
-
-    # Try multiple possible credential paths (CI/CD environments)
-    gcp_creds_path = (
-        os.getenv("GOOGLE_GHA_CREDS_PATH") or
-        os.getenv("CLOUDSDK_AUTH_CREDENTIAL_FILE_OVERRIDE") or
-        os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
-    )
-
-    # Method 1: Try to load from service account JSON file/string
-    if gcp_creds_path:
-        try:
-            os.environ["MY_TEMP_GCS_BUCKET"] = os.getenv("MY_TEMP_GCS_BUCKET", "")
-            
-            # Check if it's a file path that exists
-            if Path(gcp_creds_path).exists():
-                logger.info(f"Loading GCP credentials from file: {gcp_creds_path}")
-                with open(gcp_creds_path, "r") as f:
-                    creds_data = json.load(f)
-                auth_method = "service_account_file"
-            else:
-                # Try to parse as raw JSON string
-                logger.info("Attempting to parse GCP credentials as JSON string")
-                creds_data = json.loads(gcp_creds_path)
-                auth_method = "service_account_json"
-
-            if creds_data:
-                gcp_project_id = creds_data.get("project_id")
-                logger.info(f"✓ GCP Project ID loaded from service account: {gcp_project_id}")
-
-        except json.JSONDecodeError as e:
-            logger.warning(f"Could not parse GCP credentials as JSON. Error: {e}")
-        except FileNotFoundError as e:
-            logger.warning(f"GCP credentials file not found: {e}")
-        except Exception as e:
-            logger.error(f"Unexpected error loading GCP credentials: {e}")
-
-    # Method 2: Check for Workload Identity Federation (GitHub Actions)
-    if not gcp_project_id:
-        wif_provider = os.getenv("WORKLOAD_IDENTITY_PROVIDER")
-        wif_service_account = os.getenv("SERVICE_ACCOUNT_EMAIL")
-        
-        if wif_provider and wif_service_account:
-            try:
-                logger.info("Attempting to load project from Workload Identity Federation")
-                # WIF credentials are automatically handled by google.auth.default()
-                # when GOOGLE_APPLICATION_CREDENTIALS is not set
-                creds, project = default()
-                
-                if project:
-                    gcp_project_id = project
-                    auth_method = "workload_identity_federation"
-                    logger.info(f"✓ GCP Project ID loaded from WIF: {gcp_project_id}")
-                else:
-                    logger.debug("WIF credentials found but no project set")
-            except Exception as e:
-                logger.debug(f"Could not load from WIF: {e}")
-        else:
-            logger.debug("WIF environment variables not found")
-
-    # Method 3: Try to get project from Application Default Credentials (ADC)
-    if not gcp_project_id:
-        try:
-            logger.info("Attempting to load project from Application Default Credentials (ADC)")
-            creds, project = default()
-            
-            if project:
-                gcp_project_id = project
-                auth_method = "adc"
-                logger.info(f"✓ GCP Project ID loaded from ADC: {gcp_project_id}")
-            else:
-                logger.debug("ADC credentials found but no project set")
-        except Exception as e:
-            logger.debug(f"Could not load from ADC: {e}")
-
-    # Method 4: Try environment variables
-    if not gcp_project_id:
-        gcp_project_id = (
-            os.getenv("GOOGLE_CLOUD_PROJECT") or
-            os.getenv("GCP_PROJECT") or
-            os.getenv("GCLOUD_PROJECT") or
-            os.getenv("CLOUDSDK_CORE_PROJECT") or
-            os.getenv("CLOUDSDK_PROJECT") or
-            os.getenv("GCP_PROJECT_ID")
-        )
-        if gcp_project_id:
-            auth_method = "environment_variable"
-            logger.info(f"✓ GCP Project ID loaded from environment: {gcp_project_id}")
-
-    # Method 5: Try gcloud config as last resort
-    if not gcp_project_id:
-        try:
-            import subprocess
-            result = subprocess.run(
-                ["gcloud", "config", "get-value", "project"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-            if result.returncode == 0:
-                gcp_project_id = result.stdout.strip()
-                if gcp_project_id and gcp_project_id != "(unset)":
-                    auth_method = "gcloud_config"
-                    logger.info(f"✓ GCP Project ID loaded from gcloud config: {gcp_project_id}")
-                else:
-                    gcp_project_id = None
-        except Exception as e:
-            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": setup_config.get("voice") or os.getenv("DEFAULT_VOICE", "en-US-Neural2-F"),
-        "auth_method": auth_method,  # Track how project was loaded
-    }
-
-    # Validate required keys
-    required_keys = ["gemini_api_key", "runwayml_api_key", "gcs_bucket_name", "gcp_project_id"]
-    missing_keys = [key for key in required_keys if not config.get(key)]
-
-    if missing_keys:
-        logger.error(f"Missing required configuration: {', '.join(missing_keys)}")
-        logger.error("Configuration loading attempted via:")
-        logger.error("  1. Service account JSON file/string")
-        logger.error("  2. Workload Identity Federation (GitHub Actions)")
-        logger.error("  3. Application Default Credentials (ADC)")
-        logger.error("  4. Environment variables")
-        logger.error("  5. gcloud config")
-        logger.error("")
-        logger.error("Available environment variables:")
-        for key in [
-            "GOOGLE_GHA_CREDS_PATH",
-            "CLOUDSDK_AUTH_CREDENTIAL_FILE_OVERRIDE",
-            "GOOGLE_APPLICATION_CREDENTIALS",
-            "WORKLOAD_IDENTITY_PROVIDER",
-            "SERVICE_ACCOUNT_EMAIL",
-            "GOOGLE_CLOUD_PROJECT",
-            "GCP_PROJECT",
-            "GCP_PROJECT_ID",
-        ]:
-            logger.error(f"  {key}: {os.getenv(key, 'NOT SET')}")
-        
-        logger.error("")
-        logger.error("For local development with ADC:")
-        logger.error("  1. Run: gcloud config set project YOUR_PROJECT_ID")
-        logger.error("  2. Or set: export GCP_PROJECT_ID=YOUR_PROJECT_ID")
-        logger.error("  3. Ensure ADC is set up: gcloud auth application-default login")
-        logger.error("")
-        logger.error("For GitHub Actions with Workload Identity Federation:")
-        logger.error("  1. Set WORKLOAD_IDENTITY_PROVIDER in your workflow")
-        logger.error("  2. Set SERVICE_ACCOUNT_EMAIL in your workflow")
-        logger.error("  3. Or set GCP_PROJECT_ID directly in secrets")
-        
-        raise ValueError(
-            f"Missing required configuration: {', '.join(missing_keys)}.\n"
-            f"Please check your .env file, gcloud config, or GitHub secrets."
-        )
-
-    logger.info(f"✓ Configuration loaded successfully (auth method: {auth_method})")
-    return config
-
-
-def get_gcp_project_id() -> str:
-    """
-    Quick helper to get just the GCP project ID.
-    Useful when you only need the project ID without loading full config.
-    """
-    config = load_configuration()
-    return config["gcp_project_id"]
-
-
-# ------------------ Usage Examples ------------------
-
-if __name__ == "__main__":
-    try:
-        from dotenv import load_dotenv
-        load_dotenv()
-        config = load_configuration()
-        print("\n✓ Configuration loaded successfully!\n")
-        print("Configuration:")
-        for key, value in config.items():
-            if "key" in key.lower() and value:
-                # Mask API keys
-                print(f"  {key}: {value[:10]}...{value[-4:]}")
-            else:
-                print(f"  {key}: {value}")
-    except ValueError as e:
-        print(f"\n✗ Configuration error:\n{e}")

src/main.py

@@ -14,7 +14,7 @@ from automation import ContentAutomation
 from utils import logger
 import pandas as pd
 import warnings
-from load_config import load_configuration
+from config import load_configuration
 
 
 

src/process_csv.py

@@ -3,7 +3,7 @@ import csv
 import os, time
 from pathlib import Path
 from datetime import datetime
-from load_config import load_configuration
+from config import load_configuration, get_str
 from main import (
     run_pipeline,
 )
@@ -15,7 +15,7 @@ import argparse
 import uuid
 from cleanup_manager import process_delete_entries
 from google_src.gcs_utils import list_gcs_files
-import setup_config
+
 from asset_manager import get_video_lib, get_audio_lib, get_asset_downloader, get_content_strategy_lib
 
 DATA_DIR = Path("data")
@@ -109,20 +109,14 @@ async def process_row(row, config: dict):
     automation = ContentAutomation(
         config, dataHolder
     )
-
     content_strategy = {
         "gemini_prompt": row.get("Gemini Imagen4 Ultra Prompt (specific)", ""),
         "runway_prompt": row.get("Runway Prompt Gen4 Turbo", ""),
         "runway_veo_prompt": row.get("Veo-3.1 Fast Prompt (Text-to-Video)", ""),
         "tts_script": tts_script,
-        "captions": row.get("Captions", ""),
-        "style": "commercial",
-        "aspect_ratio": "9:16",
-        "duration": 3,
-        "brand": "Somira",
     }
 
-    result = await run_pipeline(automation, content_strategy, tts_script)
+    result = await run_pipeline(automation, content_strategy)
     logger.info(f"✅ Completed {tts_script[:20]}...: success={result.get('success', False)}")
     list_gcs_files()
     return result
@@ -353,7 +347,7 @@ Examples:
     config = load_configuration()
 
     await download_all_video(config)
-    if os.getenv("ON_SCREEN_TEXT", "false").lower() != "true" and setup_config.get_str("setup_type") in ["beats_cut", "hard_cut"]:
+    if os.getenv("ON_SCREEN_TEXT", "false").lower() != "true" and 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/social_media_publishers/instagram_publisher.py

@@ -17,10 +17,8 @@ from dotenv import load_dotenv
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 from pathlib import Path
-from load_config import load_configuration
-from main import (
-    load_content_strategies
-)
+from config import load_configuration
+from asset_manager.content_strategy_lib import get_content_strategy_lib
 import hashlib
 from google_src.gcs_utils import find_and_download_gcs_file, upload_file_to_gcs
 
@@ -153,14 +151,13 @@ async def main():
         config = load_configuration()
         scheduler = InstagramPublisher()
         
-        csv_files = sorted(DATA_DIR.glob("content_strategies*.csv"))
+        content_lib = get_content_strategy_lib()
+        df = content_lib.get_strategies()
         all_rows = []
         
-        for csv_file in csv_files:
-            print(f"📂 Reading {csv_file.name}")
-            df = load_content_strategies(str(csv_file))
-            for i, row in df.iterrows():
-                all_rows.append((csv_file.name, row.to_dict()))
+        worksheet_name = os.getenv("CONTENT_STRATEGY_GSHEET_WORKSHEET", "Instagram_Upload")
+        for i, row in df.iterrows():
+            all_rows.append((worksheet_name, row.to_dict()))
         
         print(f"📈 Found {len(all_rows)} reels to upload")
 

src/social_media_publishers/publisher.py

@@ -16,8 +16,8 @@ import time
 from pathlib import Path
 import hashlib
 
-from load_config import load_configuration
-from main import load_content_strategies
+from config import load_configuration
+from asset_manager.content_strategy_lib import get_content_strategy_lib
 from google_src.gcs_utils import find_and_download_gcs_file, upload_file_to_gcs
 
 # Import individual platform publishers
@@ -124,13 +124,18 @@ async def run_publisher(media: str, commit=False):
         sys.exit(1)
 
     # Load CSVs
-    csv_files = sorted(DATA_DIR.glob("content_strategies*.csv"))
+    # Load strategies from Google Sheet
+    content_lib = get_content_strategy_lib()
+    df = content_lib.get_strategies()
+    
+    if df.empty:
+        print("❌ No content strategies found in Google Sheet!")
+        sys.exit(1)
+
     all_rows = []
-    for csv_file in csv_files:
-        print(f"📂 Reading {csv_file.name}")
-        df = load_content_strategies(str(csv_file))
-        for i, row in df.iterrows():
-            all_rows.append((csv_file.name, row.to_dict()))
+    worksheet_name = os.getenv("CONTENT_STRATEGY_GSHEET_WORKSHEET", "Unknown_Worksheet")
+    for i, row in df.iterrows():
+        all_rows.append((worksheet_name, row.to_dict()))
 
     print(f"📈 Total rows to process: {len(all_rows)}")
 

src/social_media_publishers/tiktok_publisher.py

@@ -18,10 +18,8 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 from dotenv import load_dotenv
 from pathlib import Path
-from load_config import load_configuration
-from main import (
-    load_content_strategies
-)
+from config import load_configuration
+from asset_manager.content_strategy_lib import get_content_strategy_lib
 import hashlib
 from google_src.gcs_utils import find_and_download_gcs_file
 
@@ -182,17 +180,16 @@ class TikTokPublisher:
 # ===========================================================
 async def main():
     try:
-        config = load_configuration()
         config = load_configuration()
         scheduler = TikTokPublisher()
         
-        csv_files = sorted(DATA_DIR.glob("content_strategies*.csv"))
+        content_lib = get_content_strategy_lib()
+        df = content_lib.get_strategies()
+        
         all_rows = []
-        for csv_file in csv_files:
-            print(f"📂 Reading: {csv_file.name}")
-            df = load_content_strategies(str(csv_file))
-            for i, row in df.iterrows():
-                all_rows.append((csv_file.name, row.to_dict()))
+        worksheet_name = os.getenv("CONTENT_STRATEGY_GSHEET_WORKSHEET", "TikTok_Upload")
+        for i, row in df.iterrows():
+            all_rows.append((worksheet_name, row.to_dict()))
         
         print(f"📈 Found {len(all_rows)} TikTok videos to upload.")
         

src/social_media_publishers/youtube_publisher.py

@@ -20,10 +20,8 @@ from datetime import datetime, timedelta
 # Add parent directory to path to allow importing modules from src
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
-from load_config import load_configuration
-from main import (
-    load_content_strategies
-)
+from config import load_configuration
+from asset_manager.content_strategy_lib import get_content_strategy_lib
 from pathlib import Path
 from dotenv import load_dotenv
 import hashlib
@@ -307,12 +305,14 @@ async def main():
         # Initialize and upload
         scheduler = YouTubePublisher()
 
-        csv_files = sorted(DATA_DIR.glob("content_strategies*.csv"))
+        # Load strategies
+        content_lib = get_content_strategy_lib()
+        df = content_lib.get_strategies()
+        
         all_rows = []
-        for csv_file in csv_files:
-            df = load_content_strategies(str(csv_file))
-            for i, row in df.iterrows():
-                all_rows.append((csv_file.name, row.to_dict()))
+        worksheet_name = os.getenv("CONTENT_STRATEGY_GSHEET_WORKSHEET", "YouTube_Upload")
+        for i, row in df.iterrows():
+            all_rows.append((worksheet_name, row.to_dict()))
 
         for idx, (csv_name, row) in enumerate(all_rows):
             tts_script = row.get("TTS Script (AI Avatar)", "").strip()