Update streamlit_app.py

streamlit_app.py

@@ -1,11 +1,3 @@
-import streamlit as st
-import pkg_resources
-try:
-    st.write("google-generativeai:", pkg_resources.get_distribution("google-generativeai").version)
-except Exception:
-    st.write("google-generativeai not installed")
-
-
 # streamlit_app.py
 import os
 import time
@@ -390,7 +382,17 @@ if generate_now and not st.session_state.get("busy"):
 
                         response = None
 
-                        # Attempt modern responses API
+                        # normalize response generation across google-generativeai versions
+                        response = None
+                        genai.configure(api_key=key_to_use)
+                        fname = file_name_or_id(processed)
+                        if not fname:
+                            raise RuntimeError("Uploaded file missing name/id")
+                        
+                        system_msg = {"role": "system", "content": prompt_text}
+                        user_msg = {"role": "user", "content": "Please summarize the attached video."}
+                        
+                        # 1) responses.generate (modern)
                         try:
                             if hasattr(genai, "responses") and hasattr(genai.responses, "generate"):
                                 response = genai.responses.generate(
@@ -402,20 +404,20 @@ if generate_now and not st.session_state.get("busy"):
                                 )
                         except Exception:
                             response = None
-
-                        # Attempt GenerativeModel / fallback interfaces
+                        
+                        # 2) GenerativeModel (another modern interface)
                         if response is None:
                             try:
                                 if hasattr(genai, "GenerativeModel"):
-                                    model_obj = genai.GenerativeModel(model=model_used)
-                                    if hasattr(model_obj, "generate_content"):
-                                        response = model_obj.generate_content([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
-                                    elif hasattr(model_obj, "generate"):
-                                        response = model_obj.generate([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
+                                    gm = genai.GenerativeModel(model=model_used)
+                                    if hasattr(gm, "generate_content"):
+                                        response = gm.generate_content([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
+                                    elif hasattr(gm, "generate"):
+                                        response = gm.generate([system_msg, user_msg], files=[{"name": fname}], max_output_tokens=max_tokens)
                             except Exception:
                                 response = None
-
-                        # Attempt legacy generate/create
+                        
+                        # 3) older top-level helpers (legacy)
                         if response is None:
                             try:
                                 if hasattr(genai, "generate"):
@@ -424,93 +426,92 @@ if generate_now and not st.session_state.get("busy"):
                                     response = genai.create(model=model_used, input=[{"text": prompt_text, "files": [{"name": fname}]}], max_output_tokens=max_tokens)
                             except Exception:
                                 response = None
-
+                        
                         if response is None:
                             raise RuntimeError("No supported generate method found on google.generativeai; check SDK version or model compatibility.")
-
+                        
+                        # normalize output extraction robustly
                         outputs = []
-                        if isinstance(response, dict):
-                            for key in ("output", "candidates", "items", "responses"):
-                                val = response.get(key)
-                                if isinstance(val, list) and val:
-                                    outputs = val
-                                    break
-                            if not outputs:
-                                for v in response.values():
+                        try:
+                            if isinstance(response, dict):
+                                # common keys that hold lists
+                                for k in ("output", "candidates", "items", "responses"):
+                                    v = response.get(k)
                                     if isinstance(v, list) and v:
                                         outputs = v
                                         break
-                        else:
-                            for attr in ("output", "candidates", "items", "responses", "candidates"):
-                                val = getattr(response, attr, None)
-                                if isinstance(val, list) and val:
-                                    outputs = val
-                                    break
-
-                        if not isinstance(outputs, list):
-                            outputs = list(outputs) if outputs else []
-
+                                if not outputs:
+                                    for v in response.values():
+                                        if isinstance(v, list) and v:
+                                            outputs = v
+                                            break
+                            else:
+                                for attr in ("output", "candidates", "items", "responses"):
+                                    v = getattr(response, attr, None)
+                                    if isinstance(v, (list, tuple)) and v:
+                                        outputs = list(v)
+                                        break
+                        except Exception:
+                            outputs = []
+                        
+                        # fall back to message/text fields if no list found
+                        if not outputs:
+                            candidate_text = None
+                            if isinstance(response, dict):
+                                candidate_text = response.get("text") or response.get("message")
+                            else:
+                                candidate_text = getattr(response, "text", None) or getattr(response, "message", None)
+                            if candidate_text:
+                                outputs = [ {"text": candidate_text} ]
+                        
+                        # extract strings from outputs
                         text_pieces = []
                         for item in outputs:
-                            if item is None:
+                            if not item:
                                 continue
-                            cand = None
+                            # dict style
                             if isinstance(item, dict):
                                 for k in ("content", "text", "message", "output_text", "output"):
-                                    if k in item and item[k]:
-                                        cand = item[k]
+                                    v = item.get(k)
+                                    if v:
+                                        if isinstance(v, str):
+                                            text_pieces.append(v.strip())
+                                        elif isinstance(v, list):
+                                            for e in v:
+                                                if isinstance(e, str):
+                                                    text_pieces.append(e.strip())
+                                                elif isinstance(e, dict):
+                                                    t = e.get("text") or e.get("content")
+                                                    if t:
+                                                        text_pieces.append(str(t).strip())
                                         break
                             else:
+                                # object style
                                 for k in ("content", "text", "message", "output", "output_text"):
-                                    cand = getattr(item, k, None)
-                                    if cand:
+                                    v = getattr(item, k, None)
+                                    if v:
+                                        if isinstance(v, str):
+                                            text_pieces.append(v.strip())
+                                        elif isinstance(v, (list, tuple)):
+                                            for e in v:
+                                                if isinstance(e, str):
+                                                    text_pieces.append(e.strip())
+                                                else:
+                                                    t = getattr(e, "text", None) or getattr(e, "content", None)
+                                                    if t:
+                                                        text_pieces.append(str(t).strip())
                                         break
-                            if isinstance(cand, str):
-                                if cand.strip():
-                                    text_pieces.append(cand.strip())
-                                continue
-                            if isinstance(cand, (list, tuple)):
-                                for c in cand:
-                                    if c is None:
-                                        continue
-                                    if isinstance(c, str):
-                                        if c.strip():
-                                            text_pieces.append(c.strip())
-                                        continue
-                                    if isinstance(c, dict):
-                                        t = c.get("text") or c.get("content")
-                                    else:
-                                        t = getattr(c, "text", None) or getattr(c, "content", None)
-                                    if t:
-                                        text_pieces.append(str(t).strip())
-                                continue
-                            direct = None
-                            if isinstance(item, dict):
-                                direct = item.get("text") or item.get("output_text") or item.get("message")
-                            else:
-                                direct = getattr(item, "text", None) or getattr(item, "output_text", None) or getattr(item, "message", None)
-                            if direct:
-                                text_pieces.append(str(direct).strip())
-
-                        if not text_pieces:
-                            top_text = None
-                            if isinstance(response, dict):
-                                top_text = response.get("text") or response.get("message")
-                            else:
-                                top_text = getattr(response, "text", None) or getattr(response, "message", None)
-                            if top_text:
-                                text_pieces.append(str(top_text).strip())
-
+                        
+                        # dedupe and join
                         seen = set()
                         filtered = []
                         for t in text_pieces:
-                            if not isinstance(t, str):
-                                continue
                             if t and t not in seen:
                                 filtered.append(t)
                                 seen.add(t)
                         out = "\n\n".join(filtered)
 
+
                     except Exception as e:
                         tb = traceback.format_exc()
                         st.session_state["last_error"] = f"Responses API error: {e}\n\nDebug: {debug_info}\n\nTraceback:\n{tb}"