rm sqlite

app.py

@@ -24,8 +24,7 @@ from agent_setup import initialize_adk
 from google.genai import types
 from story_generator import create_story_prompt_from_pdf, generate_video_from_prompt
 from langchain_huggingface import HuggingFaceEndpoint
-from bigquery_uploader import upload_data_from_local_db as upload_to_bigquery
-import local_database
+from bigquery_uploader import upload_diagnosis_to_bigquery
 
 print("✅ All libraries imported successfully.")
 
@@ -106,6 +105,23 @@ def create_field_mode_ui():
             {remedy}
             """
             print("Workflow complete. Returning response.")
+
+            # Prepare data for BigQuery upload
+            diagnosis_data = {
+                "ai_diagnosis": report_title,
+                "recommended_action": remedy,
+                "confidence_score": None, # Placeholder, as confidence score is not calculated here
+                "farmer_id": "unknown", # Placeholder
+                "gps_latitude": None, # Placeholder
+                "gps_longitude": None, # Placeholder
+                "crop_type": "Maize", # Assuming maize for this app
+                "crop_variety": None, # Placeholder
+                "farmer_feedback": None, # Placeholder
+                "treatment_applied": None, # Placeholder
+                "outcome_image_id": None, # Placeholder
+            }
+            upload_diagnosis_to_bigquery(diagnosis_data)
+
             return final_response
 
         except Exception as e:
@@ -309,13 +325,7 @@ def create_settings_ui():
                 status_output = gr.Textbox(label="Sync Status", interactive=False, lines=5)
 
         def sync_data_to_cloud():
-            yield "Attempting to sync local diagnosis data to BigQuery..."
-            try:
-                # Assuming your bigquery_uploader has a function that returns a summary
-                result_message = upload_to_bigquery()
-                yield f"Sync successful!\n{result_message}"
-            except Exception as e:
-                yield f"Sync failed!\nError: {e}"
+            yield "Local data sync is no longer required as diagnoses are uploaded directly to BigQuery."
 
         sync_btn.click(
             sync_data_to_cloud,
@@ -382,8 +392,7 @@ def check_internet_connection(host="8.8.8.8", port=53, timeout=3):
 
 
 if __name__ == "__main__":
-    # Initialize local database
-    local_database.init_db()
+    # No local database initialization needed
 
     field_mode_ui = create_field_mode_ui()
     interface_list = [field_mode_ui]
@@ -429,4 +438,4 @@ if __name__ == "__main__":
     else:
         ui = field_mode_ui
 
-    ui.launch(share=True, debug=True)
+    ui.launch(share=True, debug=True)

bigquery_uploader.py

@@ -2,7 +2,8 @@
 
 from google.cloud import bigquery
 from google.cloud.exceptions import NotFound
-import local_database
+import uuid
+from datetime import datetime
 
 PROJECT_ID = "gem-creation"
 DATASET_ID = "aura_mind_glow_data"
@@ -59,54 +60,30 @@ def create_table_if_not_exists(client):
         table = client.create_table(table)  # Make an API request.
         print(f"Created table {table.project}.{table.dataset_id}.{table.table_id}")
 
-
-def upload_data_from_local_db():
-    """Uploads data from the local SQLite database to BigQuery."""
-    conn = local_database.get_db_connection()
-    if conn is None:
-        print("Could not connect to the local database.")
-        return
-
-    rows = local_database.get_all_analysis(conn)
-    if not rows:
-        print("No data to upload from the local database.")
-        conn.close()
-        return
-
+def upload_diagnosis_to_bigquery(diagnosis_data: dict):
+    """Uploads a single diagnosis record to BigQuery."""
     client = get_bigquery_client()
     if client is None:
-        conn.close()
-        return
+        print("BigQuery client not available. Cannot upload diagnosis.")
+        return "BigQuery client not available."
 
     create_dataset_if_not_exists(client)
     create_table_if_not_exists(client)
 
     table_id = f"{PROJECT_ID}.{DATASET_ID}.{TABLE_ID}"
-    # Convert rows to list of dictionaries
-    rows_to_insert = []
-    for row in rows:
-        rows_to_insert.append({
-            "analysis_id": row[0],
-            "timestamp": row[1],
-            "farmer_id": row[2],
-            "gps_latitude": row[3],
-            "gps_longitude": row[4],
-            "crop_type": row[5],
-            "crop_variety": row[6],
-            "ai_diagnosis": row[7],
-            "confidence_score": row[8],
-            "recommended_action": row[9],
-            "farmer_feedback": row[10],
-            "treatment_applied": row[11],
-            "outcome_image_id": row[12],
-        })
 
-    errors = client.insert_rows_json(table_id, rows_to_insert)  # Make an API request.
+    # Add required fields if not present
+    if "analysis_id" not in diagnosis_data:
+        diagnosis_data["analysis_id"] = str(uuid.uuid4())
+    if "timestamp" not in diagnosis_data:
+        diagnosis_data["timestamp"] = datetime.now().isoformat()
+
+    rows_to_insert = [diagnosis_data]
+
+    errors = client.insert_rows_json(table_id, rows_to_insert)
     if errors == []:
-        print("New rows have been added.")
-        local_database.clear_all_analysis(conn)
-        print("Local database cleared.")
+        print(f"Diagnosis record {diagnosis_data.get('analysis_id')} uploaded successfully to BigQuery.")
+        return "Diagnosis uploaded successfully."
     else:
-        print(f"Encountered errors while inserting rows: {errors}")
-
-    conn.close()
+        print(f"Encountered errors while inserting diagnosis record: {errors}")
+        return f"Error uploading diagnosis: {errors}"

local_database.py

@@ -1,136 +0,0 @@
-import sqlite3
-import os
-from sqlite3 import Error
-
-DB_FILE = "auramind_local.db"
-INDEX_FILE = "auramind_faiss.index"
-
-def get_db_connection():
-    """Establishes a connection to the database."""
-    conn = None
-    print(f"Attempting to connect to database: {DB_FILE}")
-    try:
-        conn = sqlite3.connect(DB_FILE)
-        conn.row_factory = sqlite3.Row
-        print(f"Successfully connected to database: {DB_FILE}")
-    except Error as e:
-        print(f"Error connecting to database: {e}")
-    return conn
-
-def init_db():
-    """
-    Initializes a more robust database schema for multimodal data.
-    - 'documents' table tracks the source files.
-    - 'chunks' table stores the individual encrypted text/image chunks.
-    - 'farm_analysis' table stores analysis data.
-    """
-    print("Initializing database...")
-    # Ensure a clean slate for development/testing
-    delete_database_and_index() 
-    
-    conn = get_db_connection()
-    if conn is None:
-        print("Database connection failed, cannot initialize.")
-        return
-    cursor = conn.cursor()
-
-    # Table to track the source documents (e.g., 'healthy_maize.txt', 'user_guide.pdf')
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS documents (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL UNIQUE
-        )
-    """
-    )
-    print("Table 'documents' checked/created.")
-
-    # Table to store each chunk of content (text or image)
-    # The faiss_id will correspond to the row number in the FAISS index
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS chunks (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            doc_id INTEGER,
-            content_type TEXT NOT NULL, -- 'text' or 'image'
-            encrypted_content BLOB NOT NULL,
-            page_num INTEGER,
-            FOREIGN KEY (doc_id) REFERENCES documents (id)
-        )
-    """
-    )
-    print("Table 'chunks' checked/created.")
-
-    # Table for farm analysis data
-    sql_create_table = """ CREATE TABLE IF NOT EXISTS farm_analysis (
-                                    analysis_id TEXT PRIMARY KEY,
-                                    timestamp TEXT NOT NULL,
-                                    farmer_id TEXT,
-                                    gps_latitude REAL,
-                                    gps_longitude REAL,
-                                    crop_type TEXT,
-                                    crop_variety TEXT,
-                                    ai_diagnosis TEXT,
-                                    confidence_score REAL,
-                                    recommended_action TEXT,
-                                    farmer_feedback TEXT,
-                                    treatment_applied TEXT,
-                                    outcome_image_id TEXT
-                                ); """
-    cursor.execute(sql_create_table)
-    print("Table 'farm_analysis' checked/created.")
-
-    conn.commit()
-    print("Database changes committed.")
-    conn.close()
-    print("Database connection closed.")
-
-def check_if_indexed():
-    """Checks if the initial database and index file exist."""
-    # A basic check. A more robust check might query the db for content.
-    return os.path.exists(DB_FILE) and os.path.exists(INDEX_FILE)
-
-def delete_database_and_index():
-    """Deletes existing db and index files for a clean rebuild."""
-    if os.path.exists(DB_FILE):
-        os.remove(DB_FILE)
-        print(f"Removed old database: {DB_FILE}")
-    if os.path.exists(INDEX_FILE):
-        os.remove(INDEX_FILE)
-        print(f"Removed old index: {INDEX_FILE}")
-
-def insert_analysis(conn, analysis_data):
-    """
-    Create a new analysis record into the farm_analysis table
-    :param conn:
-    :param analysis_data:
-    :return: project id
-    """
-    sql = """ INSERT INTO farm_analysis(analysis_id,timestamp,farmer_id,gps_latitude,gps_longitude,crop_type,crop_variety,ai_diagnosis,confidence_score,recommended_action,farmer_feedback,treatment_applied,outcome_image_id)
-              VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?) """
-    cur = conn.cursor()
-    cur.execute(sql, analysis_data)
-    conn.commit()
-    return cur.lastrowid
-
-def get_all_analysis(conn):
-    """
-    Query all rows in the farm_analysis table
-    :param conn: the Connection object
-    :return:
-    """
-    cur = conn.cursor()
-    cur.execute("SELECT * FROM farm_analysis")
-
-    rows = cur.fetchall()
-
-    return rows
-
-def clear_all_analysis(conn):
-    """
-    Delete all rows in the farm_analysis table
-    :param conn: the Connection object
-    :return:
-    """
-    sql = 'DELETE FROM farm_analysis'
-    cur = conn.cursor()
-    cur.execute(sql)
-    conn.commit()