Add DB compare and update logic

app.py

@@ -1,36 +1,214 @@
-import gradio as gr
+import os
 import json
+
+import gradio as gr
 from docx import Document  # from python-docx
+from deepdiff import DeepDiff
+import mysql.connector
+
+
+# -----------------------------
+# DB CONNECTION HELPERS
+# -----------------------------
+def get_db_connection():
+    """
+    Create and return a MySQL connection using environment variables.
+    Set these in your HF Space settings:
+        DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, DB_NAME
+    """
+    return mysql.connector.connect(
+        host=os.getenv("DB_HOST", "localhost"),
+        port=int(os.getenv("DB_PORT", "3306")),
+        user=os.getenv("DB_USER", "root"),
+        password=os.getenv("DB_PASSWORD", ""),
+        database=os.getenv("DB_NAME", "test"),
+    )
+
+
+def fetch_db_json(doc_id: str):
+    """
+    Fetch existing JSON from the database for a given doc_id.
+    Assumes a table 'documents' with columns: id, json_data.
+    """
+    conn = get_db_connection()
+    try:
+        cursor = conn.cursor()
+        query = "SELECT json_data FROM documents WHERE id = %s"
+        cursor.execute(query, (doc_id,))
+        row = cursor.fetchone()
+        if not row or row[0] is None:
+            return None
+        # If stored as TEXT, parse it as JSON.
+        return json.loads(row[0])
+    finally:
+        cursor.close()
+        conn.close()
+
+
+def update_db_json(doc_id: str, new_data: dict):
+    """
+    Update JSON content in the database for a given doc_id.
+    """
+    conn = get_db_connection()
+    try:
+        cursor = conn.cursor()
+        new_json_str = json.dumps(new_data, ensure_ascii=False)
+        query = "UPDATE documents SET json_data = %s WHERE id = %s"
+        cursor.execute(query, (new_json_str, doc_id))
+        conn.commit()
+    finally:
+        cursor.close()
+        conn.close()
+
 
-def docx_to_json(file_obj):
+# -----------------------------
+# DOCX → JSON
+# -----------------------------
+def docx_to_python_dict(file_obj):
     if file_obj is None:
-        return "No file uploaded", "{}"
-    
-    # Load docx
+        raise ValueError("No file uploaded")
+
     document = Document(file_obj.name)
-    
-    # Very simple example: collect paragraphs as a list
+
+    # Example: convert paragraphs into a simple structured dict
     paragraphs = [p.text for p in document.paragraphs if p.text.strip() != ""]
-    
-    # Build a JSON structure (customize to your needs)
+
     data = {
         "paragraphs": paragraphs,
         "paragraph_count": len(paragraphs),
     }
-    
-    return json.dumps(data, indent=2)
+    return data
+
+
+# -----------------------------
+# GRADIO CALLBACKS
+# -----------------------------
+def convert_and_compare(file_obj, doc_id):
+    """
+    1. Convert DOCX to JSON (Python dict)
+    2. Fetch old JSON from DB
+    3. Compare and return:
+        - new_json_str
+        - old_json_str (or message if none)
+        - diff_str
+    """
+    if file_obj is None:
+        return "{}", "No existing record (or doc_id missing)", "No file uploaded."
+
+    if not doc_id:
+        return "{}", "{}", "Please provide a doc_id to look up in the database."
+
+    # 1) DOCX → dict
+    try:
+        new_data = docx_to_python_dict(file_obj)
+    except Exception as e:
+        return "{}", "{}", f"Error parsing DOCX: {e}"
+
+    new_json_str = json.dumps(new_data, indent=2, ensure_ascii=False)
+
+    # 2) Fetch existing from DB
+    try:
+        old_data = fetch_db_json(doc_id)
+    except Exception as e:
+        return new_json_str, "{}", f"Error fetching from DB: {e}"
 
+    if old_data is None:
+        old_json_str = "No existing JSON found for this doc_id."
+        diff_str = "No existing data to compare. You can choose to update DB with this new JSON."
+        return new_json_str, old_json_str, diff_str
+
+    old_json_str = json.dumps(old_data, indent=2, ensure_ascii=False)
+
+    # 3) Compare with DeepDiff
+    try:
+        diff = DeepDiff(old_data, new_data, ignore_order=True)
+        if not diff:
+            diff_str = "No differences detected between DOCX JSON and DB JSON."
+        else:
+            diff_str = json.dumps(diff, indent=2, ensure_ascii=False, default=str)
+    except Exception as e:
+        diff_str = f"Error computing diff: {e}"
+
+    return new_json_str, old_json_str, diff_str
+
+
+def apply_update(doc_id, new_json_str):
+    """
+    Apply the new JSON to the DB if user confirms.
+    """
+    if not doc_id:
+        return "Please provide a doc_id."
+
+    if not new_json_str.strip():
+        return "No new JSON provided to update."
+
+    try:
+        new_data = json.loads(new_json_str)
+    except Exception as e:
+        return f"Error parsing new JSON: {e}"
+
+    try:
+        update_db_json(doc_id, new_data)
+    except Exception as e:
+        return f"Error updating DB: {e}"
+
+    return "Database updated successfully with new JSON."
+
+
+# -----------------------------
+# GRADIO UI
+# -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# DOCX → JSON & DB Sync (Prototype)")
-    
+    gr.Markdown("# DOCX → JSON → DB Sync")
+    gr.Markdown(
+        "Upload a Word (.docx) file, enter the document ID from your database, "
+        "and compare the generated JSON with what is stored in the DB. "
+        "If there are changes, you can update the DB."
+    )
+
     with gr.Row():
-        file_input = gr.File(label="Upload Word (.docx)")
-    
-    json_output = gr.Code(label="Extracted JSON", language="json")
-    
-    btn = gr.Button("Convert to JSON")
-    
-    btn.click(fn=docx_to_json, inputs=file_input, outputs=json_output)
+        file_input = gr.File(label="Upload .docx file")
+        doc_id_input = gr.Textbox(label="Document ID (as stored in DB)", placeholder="e.g. 123")
+
+    with gr.Row():
+        new_json_output = gr.Code(
+            label="New JSON (from DOCX)",
+            language="json",
+            interactive=True,
+        )
+        old_json_output = gr.Code(
+            label="Existing JSON (from DB)",
+            language="json",
+            interactive=False,
+        )
+
+    diff_output = gr.Code(
+        label="Diff (DeepDiff result)",
+        language="json",
+        interactive=False,
+    )
+
+    compare_button = gr.Button("Convert & Compare")
+    compare_button.click(
+        fn=convert_and_compare,
+        inputs=[file_input, doc_id_input],
+        outputs=[new_json_output, old_json_output, diff_output],
+    )
+
+    gr.Markdown("## Apply Update")
+    gr.Markdown(
+        "If you're happy with the changes, click below to write the **New JSON** "
+        "back into the database for this `doc_id`."
+    )
+
+    update_status = gr.Textbox(label="Update Status", interactive=False)
+
+    update_button = gr.Button("Update DB with New JSON")
+    update_button.click(
+        fn=apply_update,
+        inputs=[doc_id_input, new_json_output],
+        outputs=[update_status],
+    )
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,4 +1,4 @@
 gradio
 python-docx
 deepdiff
-mysql-connector-python  # or psycopg2 / sqlalchemy depending on your DB
+mysql-connector-python