Upload folder using huggingface_hub

app.py

@@ -1015,11 +1015,25 @@ def load_audio_retriever():
 
 @st.cache_resource
 def get_inference_client():
+    """Default client for text generation (auto-routes to available providers)."""
     from huggingface_hub import InferenceClient
     token = os.environ.get("HF_TOKEN")
     return InferenceClient(token=token)
 
 
+@st.cache_resource
+def get_inference_client_free():
+    """Free serverless client for image generation (hf-inference provider).
+
+    Without explicit provider='hf-inference', the client auto-routes to paid
+    Inference Providers (nscale, fal-ai, etc.) which return 402 when credits
+    are depleted.  FLUX.1-schnell is available for free on hf-inference.
+    """
+    from huggingface_hub import InferenceClient
+    token = os.environ.get("HF_TOKEN")
+    return InferenceClient(token=token, provider="hf-inference")
+
+
 # ---------------------------------------------------------------------------
 # Translation (German <-> English)
 # ---------------------------------------------------------------------------
@@ -1316,70 +1330,80 @@ def gen_text(prompt: str, mode: str) -> dict:
 
 
 def generate_image(prompt: str) -> dict:
-    """Generate image via HF Inference API, trying free models first. Falls back to retrieval."""
-    client = get_inference_client()
-    credits_depleted = False
-    for model_id in IMAGE_GEN_MODELS:
-        if credits_depleted and model_id == "stabilityai/stable-diffusion-xl-base-1.0":
-            logger.info("Skipping paid image model (credits depleted)")
-            continue
-        try:
-            image = client.text_to_image(prompt, model=model_id)
-            tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False, dir="/tmp")
-            image.save(tmp.name)
-            model_name = model_id.split("/")[-1]
-            return {
-                "path": tmp.name, "backend": "generative",
-                "model": model_name, "failed": False,
-            }
-        except Exception as e:
-            if _is_credit_error(e):
-                credits_depleted = True
-                logger.warning("Image model %s: credits depleted (402)", model_id)
-            else:
-                logger.warning("Image gen with %s failed: %s", model_id, e)
-            continue
-    logger.warning("All image generation models failed — falling back to retrieval")
-    result = retrieve_image(prompt)
-    if credits_depleted:
-        result["credit_error"] = True
-    return result
+    """Generate image via HF Inference API. Uses free serverless endpoint first.
+
+    Strategy:
+    1. Try FLUX.1-schnell via free hf-inference provider (no credits needed)
+    2. Try SDXL via default auto-routed provider (may need credits)
+    3. Fall back to CLIP retrieval
+    """
+    # --- Attempt 1: Free serverless (FLUX.1-schnell) ---
+    try:
+        client_free = get_inference_client_free()
+        image = client_free.text_to_image(prompt, model="black-forest-labs/FLUX.1-schnell")
+        tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False, dir="/tmp")
+        image.save(tmp.name)
+        return {
+            "path": tmp.name, "backend": "generative",
+            "model": "FLUX.1-schnell", "failed": False,
+        }
+    except Exception as e:
+        logger.warning("FLUX.1-schnell (free) failed: %s", e)
+
+    # --- Attempt 2: Auto-routed provider (may need credits) ---
+    try:
+        client = get_inference_client()
+        image = client.text_to_image(prompt, model="stabilityai/stable-diffusion-xl-base-1.0")
+        tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False, dir="/tmp")
+        image.save(tmp.name)
+        return {
+            "path": tmp.name, "backend": "generative",
+            "model": "SDXL", "failed": False,
+        }
+    except Exception as e:
+        logger.warning("SDXL (auto-route) failed: %s", e)
+
+    # --- Fallback: CLIP retrieval ---
+    logger.info("All image gen failed — using CLIP retrieval")
+    return retrieve_image(prompt)
 
 
 def generate_audio(prompt: str) -> dict:
-    """Generate audio via HF Inference API, trying free models first. Falls back to retrieval."""
+    """Generate audio via HF Inference API. Falls back to retrieval.
+
+    Note: The free HF serverless endpoint (hf-inference) does NOT support
+    the 'text-to-audio' task (MusicGen, AudioLDM, etc.).  Audio generation
+    requires paid Inference Providers.  We attempt the call and gracefully
+    fall back to CLAP-based retrieval when it fails.
+    """
     client = get_inference_client()
-    credits_depleted = False
     for model_id in AUDIO_GEN_MODELS:
-        if credits_depleted and model_id == "cvssp/audioldm2":
-            logger.info("Skipping paid audio model (credits depleted)")
-            continue
         try:
-            audio_bytes = client.text_to_audio(prompt, model=model_id)
-            suffix = ".flac" if "musicgen" in model_id else ".wav"
-            tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False, dir="/tmp")
-            if isinstance(audio_bytes, bytes):
-                tmp.write(audio_bytes)
+            # Use requests directly — huggingface_hub InferenceClient
+            # has no text_to_audio method for the hf-inference provider.
+            import requests as _requests
+            _token = os.environ.get("HF_TOKEN", "")
+            _headers = {"Authorization": f"Bearer {_token}"} if _token else {}
+            _url = f"https://router.huggingface.co/hf-inference/models/{model_id}"
+            resp = _requests.post(_url, headers=_headers, json={"inputs": prompt}, timeout=120)
+            if resp.status_code == 200 and len(resp.content) > 100:
+                suffix = ".flac" if "musicgen" in model_id else ".wav"
+                tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False, dir="/tmp")
+                tmp.write(resp.content)
                 tmp.flush()
-            else:
-                tmp.write(bytes(audio_bytes))
-                tmp.flush()
-            model_name = model_id.split("/")[-1]
-            return {
-                "path": tmp.name, "backend": "generative",
-                "model": model_name, "failed": False,
-            }
+                model_name = model_id.split("/")[-1]
+                return {
+                    "path": tmp.name, "backend": "generative",
+                    "model": model_name, "failed": False,
+                }
+            logger.warning("Audio model %s returned %s", model_id, resp.status_code)
         except Exception as e:
-            if _is_credit_error(e):
-                credits_depleted = True
-                logger.warning("Audio model %s: credits depleted (402)", model_id)
-            else:
-                logger.warning("Audio gen with %s failed: %s", model_id, e)
-            continue
-    logger.warning("All audio generation models failed — falling back to retrieval")
+            logger.warning("Audio gen with %s failed: %s", model_id, e)
+        continue
+    # All generation attempts failed — use CLAP retrieval
+    logger.info("Audio generation unavailable on free tier — using CLAP retrieval")
     result = retrieve_audio(prompt)
-    if credits_depleted:
-        result["credit_error"] = True
+    result["generation_unavailable"] = True
     return result
 
 
@@ -1475,7 +1499,7 @@ def main():
             L["backend"],
             ["generative", "retrieval"],
             format_func=lambda x: {
-                "generative": "Generative (FLUX/SDXL + MusicGen)",
+                "generative": "Generative (FLUX + CLAP retrieval)",
                 "retrieval": "Retrieval (CLIP + CLAP index)",
             }[x],
         )
@@ -1520,8 +1544,8 @@ def main():
             "extended_prompt": "Single LLM call with 3x token budget",
         }
         if backend == "generative":
-            img_info = "FLUX.1-schnell / SDXL via HF API"
-            aud_info = "MusicGen / AudioLDM2 via HF API"
+            img_info = "FLUX.1-schnell (free) via HF API"
+            aud_info = "CLAP retrieval (audio gen not on free tier)"
         else:
             img_info = "CLIP retrieval (57 images)"
             aud_info = "CLAP retrieval (104 clips)"
@@ -1879,13 +1903,25 @@ def show_results(R: dict):
             backend = ai.get("backend", "unknown")
 
             if backend == "retrieval" and R.get("backend") == "generative":
-                if ai.get("credit_error"):
+                sim = ai.get("similarity", 0)
+                if ai.get("generation_unavailable"):
+                    if kid_mode:
+                        msg = ("Soundo hat ein passendes Lied aus seiner Sammlung geholt!"
+                               if lang == "de" else
+                               "Soundo picked a matching sound from the library!")
+                        st.markdown(f'<div class="{warn_cls}">{msg}</div>',
+                                    unsafe_allow_html=True)
+                    else:
+                        st.markdown(
+                            f'<div class="{warn_cls}">Audio generation not available on free tier '
+                            f'\u2014 using CLAP retrieval (sim={sim:.3f}).</div>',
+                            unsafe_allow_html=True)
+                elif ai.get("credit_error"):
                     st.markdown(
                         f'<div class="{warn_cls}"><b>HF credits depleted</b> \u2014 '
                         f'using retrieval fallback.</div>',
                         unsafe_allow_html=True)
                 else:
-                    sim = ai.get("similarity", 0)
                     st.markdown(
                         f'<div class="{warn_cls}"><b>Retrieval fallback</b> '
                         f'(sim={sim:.3f}) \u2014 generation unavailable.</div>',