Update main.py

main.py

@@ -623,7 +623,7 @@ async def _call_gemini(text: str, summary_type: str) -> Tuple[Optional[str], Opt
         return None, "Error: Primary AI service (Gemini) not configured/available."
     logger.info(f"[Gemini Primary] Generating {summary_type} summary using {GEMINI_MODEL}. Input length: {len(text)}")
 
-    # Define prompts
+    # Define prompts (same as before)
     if summary_type == "paragraph":
         prompt = ("You are an AI model designed to provide concise summaries using British English spellings. Your output MUST be:\n"
                   "• Clear and simple language suitable for someone unfamiliar with the topic.\n"
@@ -653,9 +653,8 @@ async def _call_gemini(text: str, summary_type: str) -> Tuple[Optional[str], Opt
                   "• **Focus ONLY on the main content; strictly EXCLUDE information about website features, subscriptions, ads, cookie notices, or navigation elements. Do not include things like free/paid tiers; basic/premium memberships. Especially for ACS membership.**\n\n" # Added instruction
                   "Here is the text to summarise:")
 
-    # Input Length Check (Gemini-specific limits if known, otherwise use a large default)
-    # Flash model has 1M token context, Pro has 1M (standard) or 2M (preview)
-    MAX_INPUT_LENGTH_GEMINI = 900000 # Use a slightly conservative limit (~3.6M chars if 1 token ~ 4 chars)
+    # Input Length Check
+    MAX_INPUT_LENGTH_GEMINI = 900000
     if len(text) > MAX_INPUT_LENGTH_GEMINI:
         logger.warning(f"[Gemini Primary] Input length ({len(text)}) exceeds limit ({MAX_INPUT_LENGTH_GEMINI}). Truncating.");
         text = text[:MAX_INPUT_LENGTH_GEMINI] + "... (Content truncated)"
@@ -667,33 +666,29 @@ async def _call_gemini(text: str, summary_type: str) -> Tuple[Optional[str], Opt
         HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
         HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
         HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-        # HarmCategory.HARM_CATEGORY_UNSPECIFIED: HarmBlockThreshold.BLOCK_NONE # Usually not needed
     }
-    # Add Civic Integrity if available (might not be in all SDK versions)
     if hasattr(HarmCategory, 'HARM_CATEGORY_CIVIC_INTEGRITY'):
         safety_settings[HarmCategory.HARM_CATEGORY_CIVIC_INTEGRITY] = HarmBlockThreshold.BLOCK_NONE
 
-    logger.debug(f"[Gemini Primary] Using safety settings: { {k.name: v.name for k, v in safety_settings.items()} }") # Log names
+    logger.debug(f"[Gemini Primary] Using safety settings: { {k.name: v.name for k, v in safety_settings.items()} }")
 
     try:
         logger.debug(f"[Gemini Primary] Initializing model {GEMINI_MODEL}")
         model = genai.GenerativeModel(GEMINI_MODEL)
         logger.info(f"[Gemini Primary] Sending request to Gemini ({GEMINI_MODEL})...")
-        request_options = {"timeout": 120} # Generous timeout for Gemini
+        request_options = {"timeout": 120}
         response = await model.generate_content_async(
              full_prompt,
-             generation_config=genai.types.GenerationConfig( # Optional: Control output further
-                  # max_output_tokens=1024, # Example limit if needed
-                  # temperature=0.7,
-             ),
+             generation_config=genai.types.GenerationConfig(), # Basic config
              safety_settings=safety_settings,
              request_options=request_options
         )
         logger.info("[Gemini Primary] Received response from Gemini.")
 
-        # Check for immediate blocking reasons (more robust check)
+        # Check for immediate blocking reasons
         if response.prompt_feedback and response.prompt_feedback.block_reason:
-            block_reason_str = response.prompt_feedback.block_reason.name
+            # Use .name for the enum value if block_reason is an enum, otherwise convert to string
+            block_reason_str = getattr(response.prompt_feedback.block_reason, 'name', str(response.prompt_feedback.block_reason))
             logger.warning(f"[Gemini Primary] Request blocked by API. Reason: {block_reason_str}");
             return None, f"Sorry, the primary AI model ({GEMINI_MODEL}) blocked the request (Reason: {block_reason_str})."
 
@@ -701,37 +696,47 @@ async def _call_gemini(text: str, summary_type: str) -> Tuple[Optional[str], Opt
         summary = None
         finish_reason_str = 'UNKNOWN'
         if response.candidates:
-            candidate = response.candidates[0] # Usually only one candidate
-            finish_reason_str = candidate.finish_reason.name if candidate.finish_reason else 'N/A'
-
-            if candidate.finish_reason == genai.types.FinishReason.SAFETY:
+            candidate = response.candidates[0]
+            # *** FIX START ***
+            # Use .name attribute of the finish_reason enum for comparison
+            finish_reason_name = getattr(candidate.finish_reason, 'name', None)
+            finish_reason_str = finish_reason_name or 'N/A' # Use name if available
+
+            if finish_reason_name == 'SAFETY':
+            # *** FIX END ***
                 safety_ratings_str = ", ".join([f"{rating.category.name}: {rating.probability.name}" for rating in candidate.safety_ratings])
                 logger.warning(f"[Gemini Primary] Candidate blocked due to SAFETY. Finish Reason: {finish_reason_str}. Ratings: [{safety_ratings_str}]")
                 return None, f"Sorry, the primary AI model ({GEMINI_MODEL}) blocked the response due to safety filters ({finish_reason_str})."
-            elif candidate.finish_reason not in [genai.types.FinishReason.STOP, genai.types.FinishReason.MAX_TOKENS]:
-                 # Log other non-standard finish reasons
+            # *** FIX START ***
+            # Compare names instead of potentially non-existent enum members
+            elif finish_reason_name not in ['STOP', 'MAX_TOKENS', None]: # Also check for None
+            # *** FIX END ***
                  logger.warning(f"[Gemini Primary] Candidate finished with non-standard reason: {finish_reason_str}")
 
             # Safely access content text
             if candidate.content and candidate.content.parts:
                  summary = "".join(part.text for part in candidate.content.parts if hasattr(part, 'text'))
 
-        # Fallback check via response.text (less safe if blocked)
+        # Fallback check via response.text
         if summary is None:
             try:
                 summary = response.text
             except ValueError as e:
-                 # This often indicates blocked content when accessing .text directly
                  logger.warning(f"[Gemini Primary] Error accessing response.text (likely blocked content based on previous checks): {e}");
-                 summary = None # Ensure summary is None if access fails
+                 summary = None
 
         if summary:
             logger.info(f"[Gemini Primary] Success generating summary. Finish Reason: {finish_reason_str}. Output len: {len(summary)}");
             return summary.strip(), None
         else:
+            # If summary is still None, report the finish reason found earlier
             logger.warning(f"[Gemini Primary] Gemini returned empty summary or content was blocked. Final Finish Reason: {finish_reason_str}");
             return None, f"Sorry, the primary AI model ({GEMINI_MODEL}) did not provide a summary (Finish Reason: {finish_reason_str})."
 
+    except AttributeError as ae:
+         # Catch potential AttributeErrors during response processing if SDK structure differs
+         logger.error(f"[Gemini Primary] AttributeError during Gemini response processing: {ae}. SDK might be incompatible or response structure unexpected.", exc_info=True);
+         return None, f"Sorry, there was an issue processing the response from the primary AI service ({GEMINI_MODEL})."
     except Exception as e:
         logger.error(f"[Gemini Primary] Unexpected error during Gemini API call: {e}", exc_info=True);
         return None, f"Sorry, an unexpected error occurred while using the primary AI service ({GEMINI_MODEL})."