Update app.py

app.py

@@ -2,64 +2,134 @@
 
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from typing import Union # Correct import for Union type hints in Python < 3.10
+from typing import Union
 import sqlite3
 import os
+import pandas as pd # Import pandas for CSV reading
 
 # Define the Pydantic model for Item creation/update
 class Item(BaseModel):
-    name: str
-    description: Union[str, None] = None # Corrected syntax for Python 3.9
+    date: str
+    time: str
+    lat: float
+    lon: float
+    depth: float
+    ML: float
+    nstn: int
+    dmin: float
+    gap: int
+    trms: float
+    ERH: float
+    ERZ: float
+    fixed: str
+    nph: int
+    quality: str
 
 # Define the Pydantic model for Item update specifically (allowing partial updates)
-# This model allows all fields to be optional, so you can update just 'name' or just 'description'
 class ItemUpdate(BaseModel):
-    name: Union[str, None] = None
-    description: Union[str, None] = None
+    date: Union[str, None] = None
+    time: Union[str, None] = None
+    lat: Union[float, None] = None
+    lon: Union[float, None] = None
+    depth: Union[float, None] = None
+    ML: Union[float, None] = None
+    nstn: Union[int, None] = None
+    dmin: Union[float, None] = None
+    gap: Union[int, None] = None
+    trms: Union[float, None] = None
+    ERH: Union[float, None] = None
+    ERZ: Union[float, None] = None
+    fixed: Union[str, None] = None
+    nph: Union[int, None] = None
+    quality: Union[str, None] = None
 
 app = FastAPI()
 
 # Define the path for your SQLite database file
-# This will be created in the /app directory of your Hugging Face Space.
-# Files in /app are generally persisted across restarts within a Space.
 DATABASE_FILE = os.path.join(os.getcwd(), "data.db")
+CSV_FILE_PATH = "GDMScatalog.csv" # Path to your CSV file
 
 def get_db_connection():
     """Establishes and returns a SQLite database connection."""
     try:
         conn = sqlite3.connect(DATABASE_FILE)
-        # Configure connection to return rows as dictionaries for easier access
         conn.row_factory = sqlite3.Row
         return conn
     except sqlite3.Error as err:
         print(f"Error connecting to database: {err}")
-        # In a real-world scenario, you might want to log this error and potentially
-        # use a more sophisticated error handling strategy.
         raise HTTPException(status_code=500, detail="Database connection error")
 
 @app.on_event("startup")
 async def startup_event():
     """
     Initializes the database: creates the 'items' table if it doesn't exist.
+    Also, populates the database with data from the CSV file if the table is empty.
     This runs once when the FastAPI application starts.
     """
-    conn = None # Initialize conn to None to ensure it's closed in finally block even if connection fails
+    conn = None
     try:
         conn = get_db_connection()
         cursor = conn.cursor()
+
+        # Create table if it doesn't exist
         cursor.execute("""
             CREATE TABLE IF NOT EXISTS items (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL,
-                description TEXT
+                date TEXT NOT NULL,
+                time TEXT NOT NULL,
+                lat REAL NOT NULL,
+                lon REAL NOT NULL,
+                depth REAL NOT NULL,
+                ML REAL NOT NULL,
+                nstn INTEGER NOT NULL,
+                dmin REAL NOT NULL,
+                gap INTEGER NOT NULL,
+                trms REAL NOT NULL,
+                ERH REAL NOT NULL,
+                ERZ REAL NOT NULL,
+                fixed TEXT NOT NULL,
+                nph INTEGER NOT NULL,
+                quality TEXT NOT NULL
             )
         """)
         conn.commit()
         print(f"Database table 'items' checked/created successfully at {DATABASE_FILE}.")
+
+        # Check if the table is empty and populate from CSV
+        cursor.execute("SELECT COUNT(*) FROM items")
+        count = cursor.fetchone()[0]
+
+        if count == 0:
+            print("Table 'items' is empty. Populating from CSV file...")
+            if os.path.exists(CSV_FILE_PATH):
+                try:
+                    df = pd.read_csv(CSV_FILE_PATH)
+                    # Convert DataFrame to a list of tuples for insertion
+                    # Ensure the order of columns matches the INSERT query
+                    data_to_insert = [
+                        (row['date'], row['time'], row['lat'], row['lon'], row['depth'],
+                         row['ML'], row['nstn'], row['dmin'], row['gap'], row['trms'],
+                         row['ERH'], row['ERZ'], row['fixed'], row['nph'], row['quality'])
+                        for index, row in df.iterrows()
+                    ]
+
+                    insert_query = """
+                        INSERT INTO items (date, time, lat, lon, depth, ML, nstn, dmin, gap, trms, ERH, ERZ, fixed, nph, quality)
+                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """
+                    cursor.executemany(insert_query, data_to_insert)
+                    conn.commit()
+                    print(f"Successfully inserted {len(data_to_insert)} records from {CSV_FILE_PATH}.")
+                except Exception as e:
+                    print(f"Error populating database from CSV: {e}")
+                    conn.rollback() # Rollback if CSV insertion fails
+            else:
+                print(f"CSV file not found at {CSV_FILE_PATH}. Database not populated.")
+        else:
+            print(f"Table 'items' already contains {count} records. Skipping CSV import.")
+
     except Exception as e:
         print(f"Error during database startup: {e}")
-        # If critical tables cannot be created, the app might not function.
-        # Consider raising the exception to prevent the app from starting in a broken state.
     finally:
         if conn:
             conn.close()
@@ -67,20 +137,39 @@ async def startup_event():
 @app.get("/")
 async def root():
     """Root endpoint for the API."""
-    return {"message": "Welcome to the API!"}
+    return {"message": "Welcome to the API! https://cwadayi-sqlite-api.hf.space/items/"}
 
 @app.post("/items/")
-async def create_item(item: Item): # FastAPI automatically expects JSON body based on Pydantic model
+async def create_item(item: Item):
     """Creates a new item in the database."""
     conn = get_db_connection()
     cursor = conn.cursor()
     try:
-        query = "INSERT INTO items (name, description) VALUES (?, ?)"
-        cursor.execute(query, (item.name, item.description)) # Access data via item.name, item.description
+        query = """
+            INSERT INTO items (date, time, lat, lon, depth, ML, nstn, dmin, gap, trms, ERH, ERZ, fixed, nph, quality)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """
+        cursor.execute(query, (
+            item.date,
+            item.time,
+            item.lat,
+            item.lon,
+            item.depth,
+            item.ML,
+            item.nstn,
+            item.dmin,
+            item.gap,
+            item.trms,
+            item.ERH,
+            item.ERZ,
+            item.fixed,
+            item.nph,
+            item.quality
+        ))
         conn.commit()
         return {"message": "Item created successfully", "id": cursor.lastrowid}
     except Exception as e:
-        conn.rollback() # Rollback changes if an error occurs
+        conn.rollback()
         raise HTTPException(status_code=500, detail=f"Error creating item: {e}")
     finally:
         cursor.close()
@@ -94,7 +183,6 @@ async def read_items():
     try:
         cursor.execute("SELECT * FROM items")
         items = cursor.fetchall()
-        # Convert sqlite3.Row objects to dictionaries for JSON serialization
         return {"items": [dict(item) for item in items]}
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error reading items: {e}")
@@ -120,7 +208,7 @@ async def read_item(item_id: int):
         conn.close()
 
 @app.put("/items/{item_id}")
-async def update_item(item_id: int, item: ItemUpdate): # Use ItemUpdate for partial updates
+async def update_item(item_id: int, item: ItemUpdate):
     """Updates an existing item by its ID."""
     conn = get_db_connection()
     cursor = conn.cursor()
@@ -128,31 +216,68 @@ async def update_item(item_id: int, item: ItemUpdate): # Use ItemUpdate for part
         updates = []
         params = []
 
-        if item.name is not None:
-            updates.append("name = ?")
-            params.append(item.name)
-        if item.description is not None:
-            updates.append("description = ?")
-            params.append(item.description)
+        if item.date is not None:
+            updates.append("date = ?")
+            params.append(item.date)
+        if item.time is not None:
+            updates.append("time = ?")
+            params.append(item.time)
+        if item.lat is not None:
+            updates.append("lat = ?")
+            params.append(item.lat)
+        if item.lon is not None:
+            updates.append("lon = ?")
+            params.append(item.lon)
+        if item.depth is not None:
+            updates.append("depth = ?")
+            params.append(item.depth)
+        if item.ML is not None:
+            updates.append("ML = ?")
+            params.append(item.ML)
+        if item.nstn is not None:
+            updates.append("nstn = ?")
+            params.append(item.nstn)
+        if item.dmin is not None:
+            updates.append("dmin = ?")
+            params.append(item.dmin)
+        if item.gap is not None:
+            updates.append("gap = ?")
+            params.append(item.gap)
+        if item.trms is not None:
+            updates.append("trms = ?")
+            params.append(item.trms)
+        if item.ERH is not None:
+            updates.append("ERH = ?")
+            params.append(item.ERH)
+        if item.ERZ is not None:
+            updates.append("ERZ = ?")
+            params.append(item.ERZ)
+        if item.fixed is not None:
+            updates.append("fixed = ?")
+            params.append(item.fixed)
+        if item.nph is not None:
+            updates.append("nph = ?")
+            params.append(item.nph)
+        if item.quality is not None:
+            updates.append("quality = ?")
+            params.append(item.quality)
 
         if not updates:
-            # If no fields were provided for update, return a 400 Bad Request
             raise HTTPException(status_code=400, detail="No fields to update provided")
 
         query = f"UPDATE items SET {', '.join(updates)} WHERE id = ?"
-        params.append(item_id) # Add item_id to the end of parameters for the WHERE clause
+        params.append(item_id)
 
         cursor.execute(query, tuple(params))
         conn.commit()
 
         if cursor.rowcount == 0:
-            # If no rows were affected, the item with the given ID was not found
             raise HTTPException(status_code=404, detail="Item not found")
         return {"message": "Item updated successfully"}
-    except HTTPException: # Re-raise FastAPI's own HTTPExceptions
+    except HTTPException:
         raise
     except Exception as e:
-        conn.rollback() # Rollback changes if an error occurs
+        conn.rollback()
         raise HTTPException(status_code=500, detail=f"Error updating item: {e}")
     finally:
         cursor.close()
@@ -167,11 +292,10 @@ async def delete_item(item_id: int):
         cursor.execute("DELETE FROM items WHERE id = ?", (item_id,))
         conn.commit()
         if cursor.rowcount == 0:
-            # If no rows were affected, the item with the given ID was not found
             raise HTTPException(status_code=404, detail="Item not found")
         return {"message": "Item deleted successfully"}
     except Exception as e:
-        conn.rollback() # Rollback changes if an error occurs
+        conn.rollback()
         raise HTTPException(status_code=500, detail=f"Error deleting item: {e}")
     finally:
         cursor.close()