Spaces:

maxxcarl
/

sqlLIte

Sleeping

App Files Files Community

gcharanteja commited on Jun 3

Commit

3d4271b

1 Parent(s): f77e581

Implement SQLite server and FastAPI integration with updated Dockerfile and startup script

Browse files

Files changed (5) hide show

Dockerfile +14 -11
app.py +42 -4
requirements.txt +2 -1
sqlite_server.py +101 -0
start.sh +23 -0

Dockerfile CHANGED Viewed

@@ -1,16 +1,19 @@
- #Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
-FROM python:3.9
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
-WORKDIR /app
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
-COPY --chown=user . /app
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

+FROM python:3.9-slim
+WORKDIR /app
+# Install requirements
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+# Copy all files
+COPY . .
+# Make start.sh executable
+RUN chmod +x start.sh
+EXPOSE 8000
+EXPOSE 7860
+# Run the startup script which handles both SQLite server and FastAPI
+CMD ["./start.sh"]

app.py CHANGED Viewed

@@ -1,7 +1,45 @@
 from fastapi import FastAPI
-app = FastAPI()
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!sql "}

+import os
+import requests
 from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+app = FastAPI(title="SQLite on HF Space")
+SQLITE_URL = "http://localhost:8000"
+@app.get("/", response_class=HTMLResponse)
+def read_root():
+    return """
+    <html>
+        <head><title>SQLite HF Space</title></head>
+        <body>
+            <h1>✅ SQLite Server is Running!</h1>
+            <p>Persistent Storage: /data/sqlite.db</p>
+            <p>API Endpoint: <a href="/docs">Swagger UI</a></p>
+            <p>Direct SQLite API: <code>{}/api/v1/heartbeat</code></p>
+            <p><strong>Available Endpoints:</strong></p>
+            <ul>
+                <li>GET /api/v1/heartbeat - Health check</li>
+                <li>POST /api/v1/query - Execute SELECT queries</li>
+                <li>POST /api/v1/execute - Execute INSERT/UPDATE/DELETE</li>
+                <li>GET /api/v1/tables - List all tables</li>
+                <li>GET /api/v1/schema - Get database schema</li>
+            </ul>
+        </body>
+    </html>
+    """.format(SQLITE_URL)
+@app.get("/health")
+def health_check():
+    try:
+        response = requests.get(f"{SQLITE_URL}/api/v1/heartbeat")
+        if response.status_code == 200:
+            return {"status": "healthy", "sqlite": "up"}
+        else:
+            return {"status": "unhealthy", "sqlite": "error"}
+    except Exception as e:
+        return {"status": "error", "detail": str(e)}
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))

requirements.txt CHANGED Viewed

@@ -1,2 +1,3 @@
 fastapi
-uvicorn[standard]

 fastapi
+uvicorn[standard]
+requests

sqlite_server.py ADDED Viewed

	@@ -0,0 +1,101 @@

+import os
+import sqlite3
+import json
+from pathlib import Path
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Any
+import uvicorn
+app = FastAPI(title="SQLite Server")
+DB_PATH = "/data/sqlite.db"
+def ensure_db_exists():
+    Path("/data").mkdir(parents=True, exist_ok=True)
+    if not os.path.exists(DB_PATH):
+        conn = sqlite3.connect(DB_PATH)
+        conn.close()
+def get_connection():
+    ensure_db_exists()
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+class QueryRequest(BaseModel):
+    sql: str
+class ExecuteRequest(BaseModel):
+    sql: str
+@app.get("/api/v1/heartbeat")
+def heartbeat():
+    try:
+        conn = get_connection()
+        conn.execute("SELECT 1")
+        conn.close()
+        return {"status": "ok"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+@app.post("/api/v1/query")
+def query(request: QueryRequest):
+    try:
+        conn = get_connection()
+        cursor = conn.execute(request.sql)
+        rows = cursor.fetchall()
+        conn.close()
+        return {"data": [dict(row) for row in rows]}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+@app.post("/api/v1/execute")
+def execute(request: ExecuteRequest):
+    try:
+        conn = get_connection()
+        cursor = conn.execute(request.sql)
+        conn.commit()
+        changes = conn.total_changes
+        conn.close()
+        return {"rows_affected": cursor.rowcount, "total_changes": changes}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+@app.get("/api/v1/tables")
+def list_tables():
+    try:
+        conn = get_connection()
+        cursor = conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+        )
+        tables = [row[0] for row in cursor.fetchall()]
+        conn.close()
+        return {"tables": tables}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+@app.get("/api/v1/schema")
+def get_schema():
+    try:
+        conn = get_connection()
+        cursor = conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+        )
+        tables = [row[0] for row in cursor.fetchall()]
+        schema = {}
+        for table in tables:
+            cursor = conn.execute(f"PRAGMA table_info({table})")
+            schema[table] = [
+                {"name": col[1], "type": col[2], "notnull": col[3], "pk": col[5]}
+                for col in cursor.fetchall()
+            ]
+        conn.close()
+        return schema
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+if __name__ == "__main__":
+    ensure_db_exists()
+    uvicorn.run(app, host="0.0.0.0", port=8000)

start.sh ADDED Viewed

	@@ -0,0 +1,23 @@

+#!/bin/bash
+echo "=== Starting SQLite and FastAPI ==="
+# Define the persistent directory
+PERSIST_DIR="/data"
+mkdir -p $PERSIST_DIR
+# Start SQLite server in background
+echo "🚀 Starting SQLite server on port 8000..."
+python3 sqlite_server.py &
+SQLITE_PID=$!
+# Wait for SQLite server to start
+sleep 2
+# Start FastAPI app
+echo "🌐 Starting FastAPI app on port 7860..."
+python3 app.py &
+APP_PID=$!
+# Keep both processes alive
+wait $SQLITE_PID $APP_PID