Update api.py

api.py

@@ -211,6 +211,92 @@ The description of the problem should not exceed 100 words or so."""
 
   return prompt
 
+def evaluation(descriptions: list[str]):
+# Check if Gemini library was imported and configured
+    if not genai:
+        logger.error("Gemini client is not available or configured.")
+        raise HTTPException(status_code=503, detail="Service Unavailable: Gemini client not configured")
+
+    logger.info("Received request for specificity evaluation.")
+    interrogative_probs = []
+
+    # --- 1. Generate Problematics using Gemini ---
+    for description in descriptions:
+        prompt = f"""I want you to create a technical problematic using a problem description.
+        Here is the problem description to deal with: <problem_description>{description}</problem_description>
+        
+        The problematic must be in interrogative form.
+        As the output, I only want you to provide the problematic found, nothing else.
+        
+        Here are examples of problematics that you could create, it shows the level of specificity that you should aim for:
+        
+        Example 1: 'How can a method for allocating radio resources in a non-GSO satellite communication system, operating in frequency bands shared with geostationary satellite systems and particularly in high frequency bands such as Ka, minimize interference to geostationary systems, without causing reduced geographic coverage due to fixed high separation angle thresholds or incurring cost and sub-optimality from over-dimensioning the non-GSO satellite constellation?'
+        Example 2: 'How to address the vulnerability of on-aircraft avionics software update integrity checks to system compromises and the logistical challenges of cryptographic key management in digital signature solutions, in order to establish a more secure and logistically efficient method for updating safety-critical avionics equipment?'
+        Example 3: 'How can SIM cards be protected against collision attacks that aim to retrieve the secret key Ki by analyzing the input and output of the authentication algorithm during the standard GSM authentication process, given that current tamper-proof measures are insufficient to prevent this type of key extraction?'
+        Example 4: 'How can a Trusted Application in a GlobalPlatform compliant TEE overcome the GP specification limitations that enforce client blocking during task execution, prevent partial task execution, and delete TA execution context between commands, to function as a persistent server with stateful sessions and asynchronous communication capabilities, thereby enabling server functionalities like continuous listening and non-blocking send/receive, currently impossible due to GP's sequential task processing and stateless TA operation?'
+        
+        As far as possible, avoid using acronyms in the problematic.
+        Try to be about the same length as the examples if possible."""
+
+        try:
+            logger.info("Calling Gemini API to generate problematic...")
+            # Use the specified model and configuration
+            model_name = "gemini-2.5-flash-preview-04-17"
+            model = genai.GenerativeModel(model_name)
+    
+            response = model.generate_content(prompt)
+            # Extract the result
+            problematic_result = response.text.strip()
+            interrogative_probs.append(problematic_result)
+            logger.info("Successfully generated problematic from Gemini.")
+            logger.debug(f"Generated problematic: {problematic_result[:200]}...") # Log snippet
+    
+        except Exception as e:
+            logger.error(f"Error calling Gemini API: {e}", exc_info=True)
+            # Check for specific Gemini API errors if possible
+            raise HTTPException(status_code=502, detail=f"Failed to generate problematic using LLM: {e}")
+    
+        if not problematic_result:
+             logger.error("Gemini API returned an empty result.")
+             raise HTTPException(status_code=502, detail="LLM returned an empty problematic.")
+    
+        # --- 2. Evaluate Specificity using External API ---
+        API_URL = "https://organizedprogrammers-fastapi-problematic-specificity.hf.space"
+        endpoint = f"{API_URL}/predict"
+        data = {"text": problematic_result}
+
+    try:
+        logger.info(f"Calling specificity prediction API at {endpoint}...")
+        prediction_response = requests.post(endpoint, json=data, timeout=30) # Added timeout
+        prediction_response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+
+        score_data = prediction_response.json()
+        logger.info(f"Successfully received specificity score: {score_data}")
+
+        # Validate the received score data against Pydantic model
+        try:
+            specificity_score = SpecificityScore(**score_data)
+        except Exception as pydantic_error: # Catch validation errors
+            logger.error(f"Failed to validate specificity score response: {pydantic_error}", exc_info=True)
+            logger.error(f"Invalid data received from specificity API: {score_data}")
+            raise HTTPException(status_code=502, detail="Invalid response format from specificity prediction API.")
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error calling specificity prediction API: {e}", exc_info=True)
+        raise HTTPException(status_code=502, detail=f"Failed to call specificity prediction API: {e}")
+    except Exception as e: # Catch other potential errors like JSON decoding
+         logger.error(f"Unexpected error during specificity evaluation: {e}", exc_info=True)
+         raise HTTPException(status_code=500, detail=f"Internal error during specificity evaluation: {e}")
+
+
+    # --- 3. Return Combined Result ---
+    final_response = SpecificityEvaluationResponse(
+        problematic=problematic_result,
+        specificity=specificity_score
+    )
+    return final_response
+
+
 # --- API Endpoint ---
 # API state check route
 @app.get("/")