Upload 16 files

video_library/__main__.py

@@ -27,23 +27,45 @@ GEMINI_RPD = 500
 GEMMA_RPD = 1500
 
 
+def _build_model_configs() -> list:
+    """Build the fallback chain: Gemini key#1 -> Gemini key#2 -> Gemma key#1 -> Gemma key#2.
+
+    The bare tracking_id (no suffix) for key #1 keeps existing model_usage rows
+    valid after the upgrade. Key #2 entries are only added if GEMINI_API_KEY_2 is set.
+    """
+    from .vision_describe import ModelConfig
+
+    configs = [ModelConfig(config.GEMINI_MODEL, strip_audio=False, rpd=GEMINI_RPD,
+                           api_key=config.GEMINI_API_KEY)]
+    if config.GEMINI_API_KEY_2:
+        configs.append(ModelConfig(
+            config.GEMINI_MODEL, strip_audio=False, rpd=GEMINI_RPD,
+            api_key=config.GEMINI_API_KEY_2,
+            tracking_id=f"{config.GEMINI_MODEL}#2"))
+    configs.append(ModelConfig(config.GEMMA_MODEL, strip_audio=True, rpd=GEMMA_RPD,
+                               api_key=config.GEMINI_API_KEY))
+    if config.GEMINI_API_KEY_2:
+        configs.append(ModelConfig(
+            config.GEMMA_MODEL, strip_audio=True, rpd=GEMMA_RPD,
+            api_key=config.GEMINI_API_KEY_2,
+            tracking_id=f"{config.GEMMA_MODEL}#2"))
+    return configs
+
+
 def default_components():
     """Build the real provider, Neon store, and vision router from config/env."""
     from .stock_search import PexelsProvider
     from .catalog_store import NeonCatalogStore
-    from .vision_describe import GenAIBackend, ModelConfig, VisionRouter
+    from .vision_describe import GenAIBackend, VisionRouter
 
     store = NeonCatalogStore(config.NEON_DATABASE_URL)
     store.ensure_schema()
     provider = PexelsProvider(config.PEXELS_API_KEY)
-    configs = [
-        ModelConfig(config.GEMINI_MODEL, strip_audio=False, rpd=GEMINI_RPD),
-        ModelConfig(config.GEMMA_MODEL, strip_audio=True, rpd=GEMMA_RPD),
-    ]
     router = VisionRouter(
-        configs, store,
+        _build_model_configs(), store,
         backend_factory=lambda cfg: GenAIBackend(
-            config.GEMINI_API_KEY, cfg.model_id, strip_audio=cfg.strip_audio),
+            cfg.api_key or config.GEMINI_API_KEY, cfg.model_id,
+            strip_audio=cfg.strip_audio),
         today=_utc_date,
     )
     return provider, store, router

video_library/config.py

@@ -35,6 +35,7 @@ _load_dotenv()
 # Secrets (env only)
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "")
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")        # AI Studio key (Gemini + Gemma)
+GEMINI_API_KEY_2 = os.environ.get("GEMINI_API_KEY_2", "")    # optional: second key doubles RPD ceiling
 NEON_DATABASE_URL = os.environ.get("NEON_DATABASE_URL", "")  # Neon Postgres DSN
 
 # Vision model ids (env-overridable; defaults are confirmed AI Studio strings).

video_library/taxonomy.py

@@ -1,10 +1,21 @@
 """Mood -> symbolic search queries. Drives SEARCH only; mood assignment is Phase 2.
 
 Queries are deliberately symbolic, never literal/morbid: 'death' fetches dry
-leaves and guttering candles, never corpses or graveyards.
+leaves and guttering candles, never corpses; 'innocence' fetches bubbles and
+dandelion seeds, not children's faces (which trip Pexels' people/text rejects
+anyway). All queries lean toward abstract motion and natural imagery, which
+Pexels returns cleaner stock for than literal urban/commercial terms.
+
+After the first 36-query run on 2026-06-20 we saw 88% approval EXCEPT 'mind'
+(44% rejection) - the literal urban terms surfaced watermarked, text-overlaid
+commercial stock. Mind queries are now rewritten as abstract motion.
+
+Pattern: short symbolic noun phrase + modifier like "slow motion", "close up",
+"abstract", "silhouette". These yield cinematic, watermark-free stock.
 """
 
 MOOD_QUERIES: dict[str, list[str]] = {
+    # --- Original five (proven ~96-98% approval) ---
     "silence": [
         "mist forest slow motion", "still lake fog", "candle flame dark room",
         "empty temple morning", "quiet mountain clouds", "incense smoke close up",
@@ -13,10 +24,6 @@ MOOD_QUERIES: dict[str, list[str]] = {
         "meditation silhouette", "monk walking", "incense smoke",
         "temple interior", "prayer beads close up", "sunrise mountains calm",
     ],
-    "mind": [
-        "crowd walking blur", "traffic night timelapse", "clock close up dark",
-        "shadow hallway", "city lights abstract", "rain window night",
-    ],
     "death": [
         "dry leaves slow motion", "river dusk", "candle extinguish",
         "old tree fog", "ashes wind", "bare branches winter",
@@ -29,9 +36,56 @@ MOOD_QUERIES: dict[str, list[str]] = {
         "warm sunset hands", "flowers sunlight close up", "soft window light",
         "birds flying sunset", "gentle silhouette sunset", "warm candle room",
     ],
+
+    # --- Rewritten 'mind' (literal urban -> abstract restlessness) ---
+    "mind": [
+        "crowd walking blur slow motion", "abstract motion blur dark",
+        "swirling smoke dark background", "rippling water reflection night",
+        "flickering shadows wall", "spinning bokeh lights dark",
+    ],
+
+    # --- New: core Osho metaphors that were missing ---
+    "water": [
+        "waterfall slow motion mist", "river flowing rocks slow motion",
+        "ocean waves close up slow motion", "raindrops puddle slow motion",
+        "stream forest sunlight", "waves crashing slow motion",
+    ],
+    "fire": [
+        "bonfire flames close up night", "sparks rising slow motion dark",
+        "hearth fire slow motion", "ember glowing close up",
+        "candle flame flicker macro", "fire embers wind night",
+    ],
+    "innocence": [
+        "bubble floating sunlight slow motion", "butterfly flower close up slow motion",
+        "feather floating slow motion", "dandelion seeds wind slow motion",
+        "petals falling slow motion", "kite flying sky slow motion",
+    ],
+    "devotion": [
+        "praying hands close up", "temple bell ring slow motion",
+        "candle offering close up", "flower offering hands",
+        "incense burning altar", "bowing silhouette sunset",
+    ],
+    "awakening": [
+        "sunrise mountains timelapse", "flower blooming timelapse",
+        "dawn fog forest", "first light window slow motion",
+        "mist rising valley dawn", "lotus blooming timelapse",
+    ],
+    "seeking": [
+        "footsteps sand slow motion", "door opening light",
+        "forest path walking", "mountain trail fog",
+        "silhouette walking horizon sunset", "footprints snow slow motion",
+    ],
+    "body": [
+        "silhouette dancing sunset", "whirling dervish silhouette",
+        "hands movement slow motion", "contemporary dance silhouette",
+        "flowing fabric wind slow motion", "yoga silhouette sunrise",
+    ],
 }
 
-INITIAL_MOODS: list[str] = ["silence", "meditation", "mind", "death", "cosmic", "love"]
+INITIAL_MOODS: list[str] = [
+    "silence", "meditation", "mind", "death", "cosmic", "love",
+    "water", "fire", "innocence", "devotion", "awakening", "seeking", "body",
+]
 
 
 def queries_for(moods: list[str]) -> list[tuple[str, str]]:

video_library/vision_describe.py

@@ -184,6 +184,12 @@ class ModelConfig:
     strip_audio: bool = False
     rpd: int = 500          # requests per day (daily cap)
     rpm: int = 15           # requests per minute
+    api_key: str = ""       # if set, the backend factory uses this instead of a default
+    tracking_id: str = ""   # usage-store key; defaults to model_id (so single-key setups stay backward-compat)
+
+    def __post_init__(self):
+        if not self.tracking_id:
+            self.tracking_id = self.model_id
 
 
 class NoModelAvailableError(Exception):
@@ -214,17 +220,17 @@ class VisionRouter:
         self._recent: dict[str, list[float]] = {}
 
     def backend_for(self, cfg: ModelConfig) -> VisionBackend:
-        if cfg.model_id not in self._backends:
-            self._backends[cfg.model_id] = self._backend_factory(cfg)
-        return self._backends[cfg.model_id]
+        if cfg.tracking_id not in self._backends:
+            self._backends[cfg.tracking_id] = self._backend_factory(cfg)
+        return self._backends[cfg.tracking_id]
 
-    def mark_exhausted(self, model_id: str) -> None:
-        self._exhausted.add(model_id)
+    def mark_exhausted(self, tracking_id: str) -> None:
+        self._exhausted.add(tracking_id)
 
     def _enforce_rpm(self, cfg: ModelConfig) -> None:
         now = self.monotonic()
-        window = [t for t in self._recent.get(cfg.model_id, []) if now - t < 60.0]
-        self._recent[cfg.model_id] = window
+        window = [t for t in self._recent.get(cfg.tracking_id, []) if now - t < 60.0]
+        self._recent[cfg.tracking_id] = window
         if len(window) >= cfg.rpm:
             wait = 60.0 - (now - window[0])
             if wait > 0:
@@ -233,17 +239,17 @@ class VisionRouter:
     def pick_model(self) -> ModelConfig | None:
         date = self.today()
         for cfg in self.configs:
-            if cfg.model_id in self._exhausted:
+            if cfg.tracking_id in self._exhausted:
                 continue
-            if self.usage_store.get_usage(cfg.model_id, date) >= cfg.rpd:
+            if self.usage_store.get_usage(cfg.tracking_id, date) >= cfg.rpd:
                 continue
             self._enforce_rpm(cfg)
             return cfg
         return None
 
     def note_request(self, cfg: ModelConfig) -> None:
-        self.usage_store.note_request(cfg.model_id, self.today())
-        self._recent.setdefault(cfg.model_id, []).append(self.monotonic())
+        self.usage_store.note_request(cfg.tracking_id, self.today())
+        self._recent.setdefault(cfg.tracking_id, []).append(self.monotonic())
 
     def describe(self, video_path: str) -> Description:
         while True:
@@ -255,7 +261,7 @@ class VisionRouter:
                 desc = backend.describe(video_path)
             except Exception as e:
                 if is_quota_error(e):
-                    self.mark_exhausted(cfg.model_id)
+                    self.mark_exhausted(cfg.tracking_id)
                     continue
                 raise
             self.note_request(cfg)