Update app.py

app.py

@@ -1,96 +1,147 @@
-from fastapi import FastAPI, HTTPException, Query
-from starlette.responses import JSONResponse
-from obspy.clients.fdsn import Client
-from obspy.core.utcdatetime import UTCDateTime
-import logging
-from datetime import date
+from fastapi import FastAPI, HTTPException
+import sqlite3
+import os
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
+app = FastAPI()
 
-# Initialize the FastAPI app
-app = FastAPI(
-    title="Dynamic Earthquake Catalog API",
-    description="A robust API to fetch earthquake data from the IRIS FDSN web service using URL parameters.",
-    version="2.1.0",
-)
+# 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")
 
-# Initialize the IRIS FDSN client
-try:
-    client = Client("IRIS")
-    logging.info("Successfully initialized IRIS FDSN client.")
-except Exception as e:
-    client = None
-    logging.error(f"Could not initialize IRIS FDSN client on startup: {e}")
+def get_db_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}")
+        raise HTTPException(status_code=500, detail="Database connection error")
+
+@app.on_event("startup")
+async def startup_event():
+    # Create tables if they don't exist
+    conn = None # Initialize conn to None
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS items (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                description TEXT
+            )
+        """)
+        conn.commit()
+        print(f"Database table 'items' checked/created successfully at {DATABASE_FILE}.")
+    except Exception as e:
+        print(f"Error during database startup: {e}")
+        # In a real app, you might want to handle this more gracefully,
+        # e.g., log the error and potentially shut down if essential tables can't be created.
+    finally:
+        if conn:
+            conn.close()
 
 @app.get("/")
-def greet_json():
-    """
-    A simple 'Hello World' endpoint.
-    """
-    return {"Hello": "World!", "message": "Go to /docs to try the dynamic earthquake endpoint.  cwadayi \n https://cwadayi-python-app.hf.space/earthquakes?start_date=2024-07-01&end_date=2024-07-07&min_magnitude=5.0"}
+async def root():
+    return {"message": "Welcome to the API!"}
 
-@app.get("/earthquakes")
-async def get_earthquake_catalog(
-    start_date: date = Query(default="2024-01-01", description="Start date in YYYY-MM-DD format"),
-    end_date: date = Query(default="2024-01-07", description="End date in YYYY-MM-DD format"),
-    min_magnitude: float = Query(default=4.5, description="Minimum earthquake magnitude (e.g., 5.5)", gt=0, le=10)
-):
-    """
-    Fetches earthquake data based on date and magnitude parameters provided in the URL.
-    """
-    if not client:
-        raise HTTPException(status_code=503, detail="The IRIS FDSN client is not available.")
-    
-    if start_date > end_date:
-        raise HTTPException(status_code=400, detail="The start_date cannot be after the end_date.")
+@app.post("/items/")
+async def create_item(name: str, description: str = None):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        query = "INSERT INTO items (name, description) VALUES (?, ?)"
+        cursor.execute(query, (name, description))
+        conn.commit()
+        return {"message": "Item created successfully", "id": cursor.lastrowid}
+    except Exception as e:
+        conn.rollback()
+        raise HTTPException(status_code=500, detail=f"Error creating item: {e}")
+    finally:
+        cursor.close()
+        conn.close()
 
+@app.get("/items/")
+async def read_items():
+    conn = get_db_connection()
+    cursor = conn.cursor()
     try:
-        starttime = UTCDateTime(start_date)
-        endtime = UTCDateTime(end_date)
+        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}")
+    finally:
+        cursor.close()
+        conn.close()
 
-        logging.info(f"Fetching events from {starttime} to {endtime} with min magnitude {min_magnitude}.")
-        catalog = client.get_events(
-            starttime=starttime,
-            endtime=endtime,
-            minmagnitude=min_magnitude,
-        )
-        logging.info(f"Found {len(catalog)} events. Now processing.")
+@app.get("/items/{item_id}")
+async def read_item(item_id: int):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("SELECT * FROM items WHERE id = ?", (item_id,))
+        item = cursor.fetchone()
+        if item is None:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return dict(item)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading item: {e}")
+    finally:
+        cursor.close()
+        conn.close()
+
+@app.put("/items/{item_id}")
+async def update_item(item_id: int, name: str = None, description: str = None):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        updates = []
+        params = []
+        if name is not None:
+            updates.append("name = ?")
+            params.append(name)
+        if description is not None:
+            updates.append("description = ?")
+            params.append(description)
 
-        earthquake_list = []
-        for event in catalog:
-            try:
-                origin = event.preferred_origin()
-                magnitude = event.preferred_magnitude()
+        if not updates:
+            raise HTTPException(status_code=400, detail="No fields to update provided")
 
-                if not origin or not magnitude:
-                    continue
+        query = f"UPDATE items SET {', '.join(updates)} WHERE id = ?"
+        params.append(item_id)
 
-                # --- Key Change Start ---
-                # Safely get the description using getattr. This avoids errors if the 'descriptions'
-                # attribute doesn't exist, by providing a default empty list [].
-                place = "N/A"
-                descriptions = getattr(event, 'descriptions', [])
-                if descriptions:
-                    place = descriptions[0].text
-                # --- Key Change End ---
+        cursor.execute(query, tuple(params))
+        conn.commit()
 
-                earthquake_list.append({
-                    "time": origin.time.isoformat(),
-                    "latitude": origin.latitude,
-                    "longitude": origin.longitude,
-                    "depth_km": origin.depth / 1000.0 if origin.depth is not None else None,
-                    "magnitude": magnitude.mag,
-                    "magnitude_type": magnitude.magnitude_type,
-                    "place": place,
-                })
-            except Exception as e:
-                logging.warning(f"Skipping event due to unexpected processing error: {e}")
-                continue
-        
-        logging.info(f"Successfully processed {len(earthquake_list)} events.")
-        return JSONResponse(content={"earthquakes": earthquake_list})
+        if cursor.rowcount == 0:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return {"message": "Item updated successfully"}
+    except HTTPException: # Re-raise if it's already an HTTPException
+        raise
+    except Exception as e:
+        conn.rollback()
+        raise HTTPException(status_code=500, detail=f"Error updating item: {e}")
+    finally:
+        cursor.close()
+        conn.close()
 
+@app.delete("/items/{item_id}")
+async def delete_item(item_id: int):
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM items WHERE id = ?", (item_id,))
+        conn.commit()
+        if cursor.rowcount == 0:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return {"message": "Item deleted successfully"}
     except Exception as e:
-        logging.error(f"A major error occurred during the request: {e}")
-        raise HTTPException(status_code=500, detail=f"An internal error occurred: {e}")
+        conn.rollback()
+        raise HTTPException(status_code=500, detail=f"Error deleting item: {e}")
+    finally:
+        cursor.close()
+        conn.close()