Update main.py

main.py

@@ -89,98 +89,6 @@ def classify_query_with_gemini(query: str):
         print(f"Gemini API call ya JSON parsing mein error: {e}")
         return None
 
-# Helper function to safely call external APIs
-def call_external_api(endpoint_url, category, query, files=None):
-    """External API ko safely call karta hai aur response handle karta hai."""
-    try:
-        # Category-specific request handling based on your actual APIs
-        if category == "medicine_info":
-            # Medicine API expects JSON format with "query" parameter
-            if files:
-                # For file upload, use multipart form data
-                response = requests.post(
-                    endpoint_url, 
-                    files=files,
-                    data={"query": query},  # Medicine API uses "query" not "main_query"
-                    timeout=30
-                )
-            else:
-                # For text-only queries, use JSON
-                response = requests.post(
-                    endpoint_url, 
-                    json={"query": query},  # Medicine API uses "query" not "main_query"
-                    headers={'Content-Type': 'application/json'},
-                    timeout=30
-                )
-        
-        elif category == "disease_query":
-            # Disease query API - try multiple formats since we're not sure
-            if files:
-                response = requests.post(
-                    endpoint_url, 
-                    files=files, 
-                    data={"main_query": query},
-                    timeout=30
-                )
-            else:
-                # Try JSON first, fallback to form data if needed
-                try:
-                    response = requests.post(
-                        endpoint_url, 
-                        json={"main_query": query}, 
-                        headers={'Content-Type': 'application/json'},
-                        timeout=30
-                    )
-                except requests.exceptions.HTTPError as json_error:
-                    if json_error.response.status_code == 415:
-                        # Try form data format
-                        response = requests.post(
-                            endpoint_url, 
-                            data={"main_query": query}, 
-                            timeout=30
-                        )
-                    else:
-                        raise
-        
-        else:
-            # For other categories (skin_disease, report_reading)
-            if files:
-                response = requests.post(
-                    endpoint_url, 
-                    files=files, 
-                    data={"main_query": query}, 
-                    timeout=30
-                )
-            else:
-                response = requests.post(
-                    endpoint_url, 
-                    data={"main_query": query}, 
-                    timeout=30
-                )
-        
-        # Status code check karein
-        response.raise_for_status()
-        
-        # Content-Type check karein
-        content_type = response.headers.get('content-type', '')
-        
-        if 'application/json' in content_type:
-            return {"success": True, "data": response.json()}
-        else:
-            # Agar JSON nahi hai to text return karein
-            return {"success": True, "data": {"message": response.text}}
-            
-    except requests.exceptions.ConnectionError:
-        return {"success": False, "error": "API service unavailable. Please check if the service is running."}
-    except requests.exceptions.Timeout:
-        return {"success": False, "error": "API request timed out. Please try again."}
-    except requests.exceptions.HTTPError as e:
-        return {"success": False, "error": f"API returned error: {e.response.status_code}"}
-    except requests.exceptions.JSONDecodeError:
-        return {"success": False, "error": "API returned invalid JSON response"}
-    except Exception as e:
-        return {"success": False, "error": f"Unexpected error: {str(e)}"}
-
 # Step 4: API Routes (Endpoints)
 @app.route('/start_session', methods=['POST'])
 def start_session():
@@ -189,65 +97,6 @@ def start_session():
     print(f"Session started: {session_id}")
     return jsonify({"session_id": session_id}), 200
 
-# Temporary debugging endpoint
-@app.route('/test_api', methods=['POST'])
-def test_api():
-    """Debugging endpoint to test different API formats"""
-    data = request.get_json()
-    query = data.get('query', 'test query')
-    endpoint_url = data.get('endpoint', 'http://localhost:5001/ask')
-    
-    results = {}
-    
-    # Test 1: JSON format
-    try:
-        response = requests.post(
-            endpoint_url, 
-            json={"main_query": query}, 
-            headers={'Content-Type': 'application/json'},
-            timeout=10
-        )
-        results['json_format'] = {
-            'status_code': response.status_code,
-            'content_type': response.headers.get('content-type'),
-            'response': response.text[:200] if response.text else 'Empty'
-        }
-    except Exception as e:
-        results['json_format'] = {'error': str(e)}
-    
-    # Test 2: Form data format
-    try:
-        response = requests.post(
-            endpoint_url, 
-            data={"main_query": query}, 
-            timeout=10
-        )
-        results['form_format'] = {
-            'status_code': response.status_code,
-            'content_type': response.headers.get('content-type'),
-            'response': response.text[:200] if response.text else 'Empty'
-        }
-    except Exception as e:
-        results['form_format'] = {'error': str(e)}
-    
-    # Test 3: Alternative parameter name
-    try:
-        response = requests.post(
-            endpoint_url, 
-            json={"query": query}, 
-            headers={'Content-Type': 'application/json'},
-            timeout=10
-        )
-        results['alt_param_json'] = {
-            'status_code': response.status_code,
-            'content_type': response.headers.get('content-type'),
-            'response': response.text[:200] if response.text else 'Empty'
-        }
-    except Exception as e:
-        results['alt_param_json'] = {'error': str(e)}
-    
-    return jsonify(results)
-
 @app.route('/process_query', methods=['POST'])
 def process_query():
     data = request.get_json()
@@ -276,36 +125,23 @@ def process_query():
         }), 200
     else:
         print(f"Session {session_id}: No image required. Forwarding to '{classification.get('category')}' API.")
-        
+        # Asli API ko call karein (Abhi ke liye mock response)
         # Session se query aur classification nikalein
         query = SESSIONS[session_id].get('query')
         classification = SESSIONS[session_id].get('classification')
         category = classification['category']
         endpoint_url = API_ENDPOINTS.get(category)
-        
-        # External API call with error handling
-        api_result = call_external_api(endpoint_url, category, query)
-        
-        # Session close karein
+        if category == "medicine_info":
+            response = requests.post(endpoint_url, json={"main_query": query})
+        else:
+            response = requests.post(endpoint_url, data={"main_query": query})
         del SESSIONS[session_id]
         print(f"Session {session_id} closed.")
-        
-        if api_result["success"]:
-            return jsonify({
-                "status": "success",
-                "response": api_result["data"],
-                "category": category
-            })
-        else:
-            # API call fail ho gaya, mock response bhejein
-            return jsonify({
-                "status": "success",
-                "response": {
-                    "message": f"Service temporarily unavailable. Mock response: Information about '{query}' from {category} service.",
-                    "error_details": api_result["error"]
-                },
-                "category": category
-            })
+        return jsonify({
+            "status": "success",
+            "response": response.json(),
+            "data": f"Information about '{query}': This is a tuned response from the {classification.get('category')} service."
+        })
 
 @app.route('/process_with_image', methods=['POST'])
 def process_with_image():
@@ -329,34 +165,38 @@ def process_with_image():
     
     print(f"Session {session_id}: Image received. Preparing to forward to '{category}' API.")
 
-    # File payload prepare karein - different for different categories
-    if category == "medicine_info":
-        # Medicine API expects 'file' as the key
-        files_payload = {'file': (file.filename, file.stream, file.mimetype)}
-    else:
-        # Other APIs might expect 'photo' or 'image'
-        files_payload = {'file': (file.filename, file.stream, file.mimetype)}
-    
-    # External API call with error handling
-    api_result = call_external_api(endpoint_url, category, query, files=files_payload)
+    # *** NEW: FORWARDING LOGIC THAT MATCHES YOUR CURL COMMAND ***
+    # The file object from Flask needs its stream to be readable by `requests`
+    # We pass the file stream, filename, and mimetype to requests
+    # The dictionary key 'file' matches the '-F file=@...' part of your curl command
+    files_payload = {'file': (file.filename, file.stream, file.mimetype)}
     
-    # Session close karein
-    del SESSIONS[session_id]
-    print(f"Session {session_id} closed.")
-    
-    if api_result["success"]:
-        return jsonify({
-            "status": "success",
-            "response": api_result["data"],
-            "category": category
-        })
-    else:
-        # API call fail ho gaya, mock response bhejein
-        return jsonify({
+    # The dictionary key 'query' matches the '-F query=...' part
+    data_payload = {'query': query}
+
+    try:
+        # NOTE: Neeche di gayi line asli API call hai.
+        # Jab aapka backend service (e.g., http://localhost:5002/api/query) taiyaar ho,
+        # to is line ko uncomment kar dein.
+        
+        response_from_service = requests.post(endpoint_url, files=files_payload, data=data_payload)
+        response_from_service.raise_for_status() # Agar 4xx/5xx error ho to exception raise karega
+        tuned_response = response_from_service.json() # Assume service returns JSON
+
+        # Abhi ke liye, hum ek mock response bhej rahe hain
+        mock_response = {
             "status": "success",
-            "response": {
-                "message": f"Service temporarily unavailable. Mock response: Analysis for '{query}' based on your image from {category} service.",
-                "error_details": api_result["error"]
-            },
-            "category": category
-        })
+            "response": tuned_response,
+            "data": f"Analysis for '{query}' based on your image: This is a tuned MOCK response from the {category} service."
+        }
+        
+        # Session close karein
+        del SESSIONS[session_id]
+        print(f"Session {session_id} closed.")
+        
+        return jsonify(mock_response)
+
+    except requests.exceptions.RequestException as e:
+        del SESSIONS[session_id]
+        print(f"Session {session_id} closed after failed API call.")
+        return jsonify({"status": "error", "message": f"Backend service call failed: {e}"}), 503