Update app.py

app.py

@@ -36,36 +36,54 @@ def create_chat_session():
     session_id = response_data['data']['id']
     return session_id
 
-# Step 2: Submit a query to the API
 def submit_query(session_id, query):
-    submit_query_url = f'https://api.on-demand.io/chat/v1/sessions/{session_id}/query'
-    submit_query_headers = {
-        'apikey': api_key
-    }
-    submit_query_body = {
-        "endpointId": "predefined-openai-gpt4o",
-        "query": query,
-        "pluginIds": ["plugin-1712327325", "plugin-1713962163"],
-        "responseMode": "sync"
-    }
-    response = requests.post(submit_query_url, headers=submit_query_headers, json=submit_query_body)
-    return response.json()
+    try:
+        submit_query_url = f'https://api.on-demand.io/chat/v1/sessions/{session_id}/query'
+        submit_query_headers = {
+            'apikey': api_key
+        }
+        submit_query_body = {
+            "endpointId": "predefined-openai-gpt4o",
+            "query": query,
+            "pluginIds": ["plugin-1712327325", "plugin-1713962163"],
+            "responseMode": "sync"
+        }
+
+        # Log the query sent to the API
+        logger.info(f"Sending query to LLM API: {query}")
+
+        response = requests.post(submit_query_url, headers=submit_query_headers, json=submit_query_body)
+        logger.info(f"LLM API response status: {response.status_code}")
+        
+        if response.status_code != 200:
+            logger.error(f"LLM API call failed with status code {response.status_code}")
+            return None
+        
+        # Return the JSON response
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error submitting query to LLM API: {str(e)}")
+        raise
 
 def extract_json_from_answer(answer):
     """Extract and clean JSON from the LLM response"""
     try:
-        # First try to parse the answer directly
+        # Try to parse the answer directly as JSON
+        logger.info(f"Trying to parse the LLM answer as JSON: {answer}")
         return json.loads(answer)
     except json.JSONDecodeError:
+        logger.warning("Direct JSON parse failed, trying to extract JSON content")
         try:
-            # If that fails, try to find JSON content and parse it
+            # Attempt to find and parse JSON content within the answer
             start_idx = answer.find('{')
             end_idx = answer.rfind('}') + 1
             if start_idx != -1 and end_idx != 0:
                 json_str = answer[start_idx:end_idx]
+                logger.info(f"Extracted JSON string: {json_str}")
                 return json.loads(json_str)
-        except (json.JSONDecodeError, ValueError):
-            logger.error("Failed to parse JSON from response")
+        except (json.JSONDecodeError, ValueError) as parse_error:
+            logger.error(f"Failed to parse JSON from response: {str(parse_error)}")
             raise
 
 def load_model():
@@ -188,41 +206,106 @@ def gradio_interface(patient_info, image):
             "details": "Check the application logs for more information"
         }, indent=2)
 
-# Gradio interface
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs=[
-        gr.Textbox(
-            label="Patient Information",
-            placeholder="Enter patient details including: symptoms, medical history, current medications, age, gender, and any relevant test results...",
-            lines=5,
-            max_lines=10
-        ),
-        gr.Image(
-            label="Medical Image",
-            type="pil",
-            interactive=True
-        )
-    ],
-    outputs=gr.Textbox(
-        label="Medical Analysis",
-        placeholder="JSON analysis will appear here...",
-        lines=15
-    ),
-    title="Medical Diagnosis Assistant",
-    description="Enter patient information and optionally upload a medical image for analysis."
-)
 
-if __name__ == "__main__":
-    # Add version information logging
-    logger.info(f"TensorFlow Keras version: {tf_keras.__version__}")
-    logger.info(f"TensorFlow Hub version: {hub.__version__}")
-    logger.info(f"Gradio version: {gr.__version__}")
+def gradio_interface(patient_info, image):
+    try:
+        if model is None:
+            logger.error("Model is not initialized")
+            return json.dumps({
+                "error": "Model initialization failed. Please check the logs for details.",
+                "status": "error"
+            }, indent=2)
+
+        classes = ["Alzheimer's", "Stroke", "Tumor", "Normal"]
+        image_analysis = None
+
+        # Process the image if provided
+        if image is not None:
+            logger.info("Processing uploaded image")
+            processed_image = preprocess_image(image)
+            
+            logger.info("Running model prediction")
+            prediction = model.predict(processed_image)
+            
+            logger.info(f"Raw prediction: {prediction}")
+            # Assume the first prediction corresponds to the class
+            predicted_class_index = int(np.argmax(prediction))
+            predicted_confidence = np.max(prediction) * 100
+            
+            image_analysis = {
+                "prediction": classes[predicted_class_index],
+                "confidence": predicted_confidence
+            }
+            logger.info(f"Image analysis results: {image_analysis}")
+
+        # Append image analysis to patient info
+        patient_info += f"\nPrediction based on MRI images: {image_analysis['prediction']}, Confidence: {image_analysis['confidence']}"
+
+        # Log the patient info sent to the API
+        logger.info(f"Submitting the following patient info to LLM: {patient_info}")
+
+        # Create a session and submit the query
+        session_id = create_chat_session()
+        llm_response = submit_query(session_id, patient_info)
+
+        # Log the raw response from the LLM API
+        logger.info(f"LLM API response: {llm_response}")
+
+        if not llm_response or 'data' not in llm_response or 'answer' not in llm_response['data']:
+            logger.error("Invalid response structure from LLM")
+            return json.dumps({
+                "error": "Invalid LLM response structure.",
+                "status": "error"
+            }, indent=2)
+        
+        # Extract the answer and parse the JSON from the response
+        json_data = extract_json_from_answer(llm_response['data']['answer'])
+
+        return json.dumps(json_data, indent=2)
+        
+    except Exception as e:
+        logger.error(f"Error in gradio_interface: {str(e)}")
+        return json.dumps({
+            "error": str(e),
+            "status": "error",
+            "details": "Check the application logs for more information"
+        }, indent=2)
+
+# # Gradio interface
+# iface = gr.Interface(
+#     fn=gradio_interface,
+#     inputs=[
+#         gr.Textbox(
+#             label="Patient Information",
+#             placeholder="Enter patient details including: symptoms, medical history, current medications, age, gender, and any relevant test results...",
+#             lines=5,
+#             max_lines=10
+#         ),
+#         gr.Image(
+#             label="Medical Image",
+#             type="pil",
+#             interactive=True
+#         )
+#     ],
+#     outputs=gr.Textbox(
+#         label="Medical Analysis",
+#         placeholder="JSON analysis will appear here...",
+#         lines=15
+#     ),
+#     title="Medical Diagnosis Assistant",
+#     description="Enter patient information and optionally upload a medical image for analysis."
+# )
+
+# if __name__ == "__main__":
+#     # Add version information logging
+#     logger.info(f"TensorFlow Keras version: {tf_keras.__version__}")
+#     logger.info(f"TensorFlow Hub version: {hub.__version__}")
+#     logger.info(f"Gradio version: {gr.__version__}")
     
-    iface.launch(
-        server_name="0.0.0.0",
-        debug=True
-    )
+#     iface.launch(
+#         server_name="0.0.0.0",
+#         debug=True
+#     )