Update app.py

app.py

@@ -1,70 +1,178 @@
 # app.py
 
 from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel # <--- Import BaseModel
+from pydantic import BaseModel
+from typing import Union # Correct import for Union type hints in Python < 3.10
 import sqlite3
 import os
 
 # Define the Pydantic model for Item creation/update
 class Item(BaseModel):
     name: str
-    description: str | None = None # Use Union type hint for None
+    description: Union[str, None] = None # Corrected syntax for Python 3.9
+
+# 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
 
 app = FastAPI()
 
-# ... rest of your existing code ...
+# 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")
+
+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.
+    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
+    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}")
+        # 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()
+
+@app.get("/")
+async def root():
+    """Root endpoint for the API."""
+    return {"message": "Welcome to the API!"}
 
 @app.post("/items/")
-async def create_item(item: Item): # <--- Change parameter to 'item: Item'
+async def create_item(item: Item): # FastAPI automatically expects JSON body based on Pydantic model
+    """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 attributes using item.name, item.description
+        cursor.execute(query, (item.name, item.description)) # Access data via item.name, item.description
         conn.commit()
         return {"message": "Item created successfully", "id": cursor.lastrowid}
     except Exception as e:
-        conn.rollback()
+        conn.rollback() # Rollback changes if an error occurs
         raise HTTPException(status_code=500, detail=f"Error creating item: {e}")
     finally:
         cursor.close()
         conn.close()
 
-# ... Also update your @app.put("/items/{item_id}") endpoint similarly ...
+@app.get("/items/")
+async def read_items():
+    """Retrieves all items from the database."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    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}")
+    finally:
+        cursor.close()
+        conn.close()
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: int):
+    """Retrieves a single item by its ID."""
+    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, item: Item): # <--- Change parameter to 'item: Item'
+async def update_item(item_id: int, item: ItemUpdate): # Use ItemUpdate for partial updates
+    """Updates an existing item by its ID."""
     conn = get_db_connection()
     cursor = conn.cursor()
     try:
         updates = []
         params = []
 
-        if item.name is not None: # Access using item.name
+        if item.name is not None:
             updates.append("name = ?")
             params.append(item.name)
-        if item.description is not None: # Access using item.description
+        if item.description is not None:
             updates.append("description = ?")
             params.append(item.description)
 
         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)
+        params.append(item_id) # Add item_id to the end of parameters for the WHERE clause
 
         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 if it's already an HTTPException
+    except HTTPException: # Re-raise FastAPI's own HTTPExceptions
         raise
     except Exception as e:
-        conn.rollback()
+        conn.rollback() # Rollback changes if an error occurs
         raise HTTPException(status_code=500, detail=f"Error updating item: {e}")
     finally:
         cursor.close()
         conn.close()
 
-# ... rest of your existing code ...
+@app.delete("/items/{item_id}")
+async def delete_item(item_id: int):
+    """Deletes an item by its ID."""
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        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
+        raise HTTPException(status_code=500, detail=f"Error deleting item: {e}")
+    finally:
+        cursor.close()
+        conn.close()