Update api.py

api.py

@@ -80,7 +80,7 @@ def get_content(number: str, node_type: str) -> str:
         logger.error(f"An unexpected error occurred in get_content for {number}: {e}")
         return ""
 
-def extract_research_paper_arxiv(rp_number: str, node_type: str = "ResearchPaper") -> dict:
+def extract_arxiv(rp_number: str, node_type: str = "ResearchPaper") -> dict:
     """Extracts information from an Arxiv research paper and generates a summary."""
     
     rp_data = {
@@ -154,7 +154,7 @@ def extract_research_paper_arxiv(rp_number: str, node_type: str = "ResearchPaper
         rp_data["summary"] = "Summary not generated (Abstract unavailable or problematic)"
     return rp_data
 
-def extract_patent_data(patent_number: str, node_type: str = "Patent"):
+def extract_google_patents(patent_number: str, node_type: str = "Patent"):
     """
     Extracts information from a Google Patents page with robust error handling.
     """
@@ -223,19 +223,19 @@ def extract_patent_data(patent_number: str, node_type: str = "Patent"):
         
         prompt = f"""You are a 3GPP standardization expert. Summarize the key information in the provided document in simple technical English relevant to identifying potential Key Issues.
         Focus on challenges, gaps, or novel aspects.
-        Here is the document: <document>{rp_data['abstract']}<document>"""
+        Here is the document: <document>{patent_data['description']}<document>"""
         
         try:
             model = genai.GenerativeModel("gemini-2.5-flash-preview-05-20")
             response = model.generate_content(prompt)
     
-            rp_data["summary"] = response.text
+            patent_data["summary"] = response.text
             logger.info(f"Summary generated for Patent ID: {patent_number}")
         except Exception as e:
             logger.error(f"Error generating summary with Gemini for Patent ID {patent_number}: {e}")
-            rp_data["summary"] = "Error generating summary (API failure)"
+            patent_data["summary"] = "Error generating summary (API failure)"
     else:
-        rp_data["summary"] = "Summary not generated (Abstract unavailable or problematic)"
+        rp_data["summary"] = "Summary not generated (Description unavailable or problematic)"
     return patent_data
 
 def add_nodes_to_neo4j(driver, data_list: list, node_type: str):
@@ -291,7 +291,7 @@ async def add_single_research_paper(arxiv_id: str):
         raise HTTPException(status_code=500, detail="Neo4j database connection details are not configured on the server.")
 
     # Step 1: Extract paper data
-    paper_data = extract_research_paper_arxiv(arxiv_id, node_type)
+    paper_data = extract_arxiv(arxiv_id, node_type)
 
     if paper_data["title"].startswith("Error fetching content") or paper_data["title"] == "Title not found on page":
         logger.warning(f"Could not fetch or parse content for Arxiv ID {arxiv_id}. Title: {paper_data['title']}")
@@ -325,6 +325,60 @@ async def add_single_research_paper(arxiv_id: str):
     except Exception as e:
         logger.error(f"An unexpected error occurred during Neo4j operation for {arxiv_id}: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"An unexpected server error occurred: {e}")
+    finally:
+        if driver_instance:
+            driver_instance.close()
+            logger.info("Neo4j connection closed.")
+
+
+@app.post("/add_patent/{patent_id}", status_code=201) # 201 Created for successful creation
+async def add_single_patent(patent_id: str):
+    """
+    Fetches a patent from Google Patents by its ID, extracts information,
+    generates a summary, and adds/updates it as a 'Patent' node in Neo4j.
+    """
+    node_type = "Patent"
+    logger.info(f"Processing request for Patent ID: {patent_id}")
+
+    if not NEO4J_URI or not NEO4J_USER or not NEO4J_PASSWORD:
+        logger.error("Neo4j database connection details are not configured on the server.")
+        raise HTTPException(status_code=500, detail="Neo4j database connection details are not configured on the server.")
+
+    # Step 1: Extract patent data
+    patent_data = extract_google_patents(patent_id, node_type)
+
+    if patent_data["title"].startswith("Error fetching content") or patent_data["title"] == "Title not found on page":
+        logger.warning(f"Could not fetch or parse content for Patent ID {patent_id}. Title: {patent_data['title']}")
+        raise HTTPException(status_code=404, detail=f"Could not fetch or parse content for Patent ID {patent_id}. Title: {patent_data['title']}")
+
+    # Step 2: Add/Update in Neo4j
+    driver_instance = None # Initialize for the finally block
+    try:
+        auth_token = basic_auth(NEO4J_USER, NEO4J_PASSWORD)
+        driver_instance = GraphDatabase.driver(NEO4J_URI, auth=auth_token)
+        driver_instance.verify_connectivity()
+        logger.info("Successfully connected to Neo4j.")
+        
+        nodes_created_count = add_nodes_to_neo4j(driver_instance, [patent_data], node_type)
+            
+        if nodes_created_count > 0 :
+            logger.info(f"Patent {patent_id} was successfully added to Neo4j.")
+            status_code_response = 201 # Created
+        
+        # Note: FastAPI uses the status_code from the decorator or HTTPException.
+        # This custom status_code_response is for the JSON body if needed, but the actual HTTP response status
+        # will be 201 (from decorator) unless an HTTPException overrides it or we change the decorator based on logic.
+        # For simplicity here, we'll return it in the body and let the decorator's 201 stand if no error.
+        # A more advanced setup might change the response status dynamically.
+        
+        return {"data": patent_data}
+
+    except HTTPException as e: # Re-raise HTTPExceptions
+        logger.error(f"HTTPException during Neo4j operation for {patent_id}: {e.detail}")
+        raise e
+    except Exception as e:
+        logger.error(f"An unexpected error occurred during Neo4j operation for {patent_id}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"An unexpected server error occurred: {e}")
     finally:
         if driver_instance:
             driver_instance.close()