update rm.py

rm.py

@@ -6,73 +6,105 @@ from flask import Flask, request, jsonify
 from flask_cors import CORS
 from google import genai
 import json
+from dotenv import load_dotenv
+load_dotenv()
 
-
-
-
-f_app = FirecrawlApp(api_key=os.getenv("FIRECRAWL_API_KEY"))
+f_app = FirecrawlApp(api_key="fc-518f9c40ee8d4bb18a18c9a79bafba24")
 app = Flask(__name__)
+app.config['JSON_SORT_KEYS'] = False  # To keep the order of keys in JSON response
+app.config['CORS_HEADERS'] = 'Content-Type'
+app.config['CORS_RESOURCES'] = {r"/*": {"origins": "*"}}
+app.config['CORS_SUPPORTS_CREDENTIALS'] = True
+app.config['CORS_METHODS'] = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']
 CORS(app)
 
-client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
-
+client = genai.Client(api_key="AIzaSyDjDn3YjUNgHk_hkBNK1GOEBJjXnZXqLPU")
 
 SYSTEM_PROMPT = os.getenv("SYSTEM_PROMPT")
 
-def get_google_scholar_results(key_params: dict):
-    key_params['api_key'] = os.getenv("SERPAPI_API_KEY")
+def get_google_scholar_results(key_params: dict, location: str | None = None):
+    """
+    Calls SerpAPI for Google Scholar results. If `location` is provided,
+    we additionally filter the returned author profiles to those whose
+    affiliations (or related fields) contain the location string.
+    """
+    key_params['api_key'] = "525fcda2cd63c50dba6f9f5eb2c8a9a09e0722fc9cc00f54c0e2f232b00acd09"
     key_params['engine'] = "google_scholar"
     key_params['hl'] = "en"
     search = GoogleSearch(key_params)
     results = search.get_dict()
-    if "profiles" in results and "organic_results" in results:
-        return results["profiles"],results["organic_results"]
-    elif "profiles" in results:
-        return results["profiles"],None
-    elif "organic_results" in results:
-        return None,results["organic_results"]
-    else:
-        return None,None
 
-def get_results(query: str):
+    profiles = results.get("profiles")
+    organic = results.get("organic_results")
+
+    # Optional location-based filtering on profiles
+    if profiles and location:
+        loc = location.strip().lower()
+        filtered = []
+        for p in profiles:
+            haystack_parts = [
+                str(p.get("name", "")),
+                str(p.get("affiliations", "")),
+                str(p.get("description", "")),
+                str(p.get("position", "")),
+                str(p.get("link", "")),
+                str(p.get("email", "")),
+            ]
+            haystack = " | ".join(haystack_parts).lower()
+            if loc in haystack:
+                filtered.append(p)
+        profiles = filtered
+
+    return profiles, organic
+
+def get_results(query):
     '''
-    This function is used to get the results from the Google Scholar API.
-    It takes a query as input and returns a list of dictionaries, each containing the information about a paper/author.
-    The keys of the dictionaries are the fields of the paper.
+    Location-aware Google Scholar retrieval.
+
+    Accepts either:
+      - a string query, or
+      - a dict with keys {"query" or "q", "location" (optional)}
 
-    Keys of the dictionary are:
-        dict_keys(['position', 'title', 'result_id', 'link', 'snippet', 'publication_info', 'resources', 'inline_links'])
+    Returns:
+      profiles: filtered (by location if provided)
+      answer:   simplified list of organic results (title, link, etc.)
+      keys:     keys present in the first organic result (if any)
     '''
-    params = {
-        "q": query,
-    }
+    if isinstance(query, dict):
+        q = query.get("query") or query.get("q") or ""
+        location = query.get("location")
+    else:
+        q = str(query)
+        location = None
 
-    answer = []
+    q_for_scholar = f"{q} {location}".strip() if location else q
+    params = {"q": q_for_scholar}
 
-    profiles,result = get_google_scholar_results(params)
-    keys = result[0].keys()
-    for i in range(len(result)):
-        output = {}
-        if "title" in result[i]:
-            output["title"] = result[i]["title"]
-        if "result_id" in result[i]:
-            output["result_id"] = result[i]["result_id"]
-        if "link" in result[i]:
-            output["link"] = result[i]["link"]
-            print(f"\n {output['link']}")
-            if "https://www.annualreviews" in result[i]["link"]:
-                output["abstract"] = get_abstract(result[i]["link"])
-        if "snippet" in result[i]:
-            output["snippet"] = result[i]["snippet"]
-        if "publication_info" in result[i]:
-            output["publication_info"] = result[i]["publication_info"]
-        if "resources" in result[i]:
-            output["resources"] = result[i]["resources"]
-        
-        answer.append(output)
-    
-
-    return profiles,answer,keys
+    answer = []
+    profiles, result = get_google_scholar_results(params, location=location)
+    keys = result[0].keys() if result and len(result) > 0 else []
+
+    if result:
+        for item in result:
+            output = {}
+            if "title" in item:
+                output["title"] = item["title"]
+            if "result_id" in item:
+                output["result_id"] = item["result_id"]
+            if "link" in item:
+                output["link"] = item["link"]
+                print(f"\n {output['link']}")
+                if "https://www.annualreviews" in item["link"]:
+                    output["abstract"] = get_abstract(item["link"])
+            if "snippet" in item:
+                output["snippet"] = item["snippet"]
+            if "publication_info" in item:
+                output["publication_info"] = item["publication_info"]
+            if "resources" in item:
+                output["resources"] = item["resources"]
+            answer.append(output)
+
+    return profiles, answer, keys
 
 def get_abstract(url: str):
     scrape_result = f_app.scrape_url(url, formats=['markdown', 'html'])
@@ -80,17 +112,13 @@ def get_abstract(url: str):
         offset = scrape_result.html.find("Abstract")
         start = scrape_result.html[offset:].find("<p>")
         end = scrape_result.html[offset+start:].find("</p>")
-        print(offset,start,end,sep="\t")
+        print(offset, start, end, sep="\t")
         print(f"\n {scrape_result.html[offset+start:offset+start+end]}")
         return scrape_result.html[offset+start:offset+start+end]
     else:
         return "Abstract not found"
 
 def scrape_web(url:str):
-    '''
-    This function is used inorder to scrape any websitye based on its url
-    Returns the html code of the webpage 
-    '''
     scrape_result = f_app.scrape_url(url, formats=['markdown', 'html'])
     return scrape_result.html
 
@@ -101,22 +129,27 @@ def get_response(chat_client,user):
 def convert_to_json(text):
     start = text.find("{")
     end = text[::-1].find("}")
-    json_text = text[start : -end]
+    json_text = text[start : -end] if end != -1 else text[start:]
     try:
         return json.loads(json_text)
     except Exception as e:
         return "Json Parse Error due to " + str(e)
 
-def get_observation(function,inp):
+def get_observation(function, inp):
     functions = ["get_results","scrape_web"]
     if function == functions[0]:
-        profiles,answer,keys = get_results(inp)
+        if isinstance(inp, dict):
+            q = inp.get("query") or inp.get("q") or ""
+            location = inp.get("location")
+            profiles, answer, keys = get_results({"query": q, "location": location})
+        else:
+            profiles, answer, keys = get_results(inp)
         out_dict = {
             "state" : "OBSERVATION",
             "observation" : {
-            "profiles" : profiles,
-            "answer" : answer,
-            "keys" : keys
+                "profiles" : profiles,
+                "answer" : answer,
+                "keys" : list(keys) if keys else []
             }
         }
     elif function == functions[1]:
@@ -124,81 +157,77 @@ def get_observation(function,inp):
         out_dict = {
             "state" : "OBSERVATION",
             "observation" : {
-            "html_text" : html_text
+                "html_text" : html_text
             }
         }
     else:
         out_dict = {
             "state" : "OBSERVATION",
             "observation" : {
-            "message":"Function Not found, Please Retry"
+                "message":"Function Not found, Please Retry"
             }
         }
     return out_dict
 
-def get_output(chat_client,inp):
-    response = get_response(chat_client,str(inp))
+def get_output(chat_client, inp):
+    response = get_response(chat_client, str(inp))
     output = convert_to_json(response)
-    while output["state"] != "OUTPUT":
-        if output["state"] == "PLAN":
-            response = get_response(chat_client,str(output))
+    while isinstance(output, dict) and output.get("state") != "OUTPUT":
+        if output.get("state") == "PLAN":
+            response = get_response(chat_client, str(output))
             output = convert_to_json(response)
             print(output)
-        elif output["state"] == "CALL":
-            function = output["function_name"]
-            for i in output["params"].keys():
-                inp = output["params"][i]
-                print(inp)
-            obs = get_observation(function,inp)
-            response = get_response(chat_client,str(obs))
+        elif output.get("state") == "CALL":
+            function = output.get("function_name")
+            params_obj = output.get("params", {})
+            inp_to_fn = params_obj if isinstance(params_obj, dict) and params_obj else None
+            if not inp_to_fn:
+                for i in params_obj.keys():
+                    inp_to_fn = params_obj[i]
+                    print(inp_to_fn)
+            obs = get_observation(function, inp_to_fn)
+            response = get_response(chat_client, str(obs))
             output = convert_to_json(response)
             print(output)
-        elif output["state"] == "OBSERVATION":
-            response = get_response(chat_client,str(output))
+        elif output.get("state") == "OBSERVATION":
+            response = get_response(chat_client, str(output))
             output = convert_to_json(response)
             print(output)
         else:
-            response = get_response(chat_client,str(output))
+            response = get_response(chat_client, str(output))
             output = convert_to_json(response)
             print(output)
     return output
-            
-    
-
 
 def chat(query: str):
     chat_client = client.chats.create(
         model="gemini-2.5-flash"
     )
-    response = get_response(chat_client,SYSTEM_PROMPT)
+    _ = get_response(chat_client, SYSTEM_PROMPT)
     inp = {
-    "state" : "START",
-    "user" : query
+        "state" : "START",
+        "user" : query
     }
-
-    output = get_output(chat_client,inp)
+    output = get_output(chat_client, inp)
     return output["output"]
 
 @app.route("/",methods=["GET"])
 def default():
     return jsonify({"message": "Backend Working Successfully"})
 
-@app.route("/chat",methods=["POST","GET"])
+@app.route("/chat", methods=["POST","GET"])
 def get_chat_results():
-    query = request.json.get("query")
-    output = chat(query)
-    return jsonify({"output":output})
-
-
-
-
-
-    
-
-
-
-
+    if request.method == "POST":
+        # Expect JSON body
+        data = request.get_json(silent=True) or {}
+        query = data.get("query")
+    else:  # GET
+        query = request.args.get("query")
 
+    if not query:
+        return jsonify({"error": "No query provided"}), 400
 
+    output = chat(query)
+    return jsonify({"output": output})