add a basic backend skeleton

.github/workflows/lint.yml

@@ -0,0 +1,21 @@
+name: Lint with black
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: backend
+    steps:
+      - name: setup
+        uses: actions/checkout@v3
+      - name: setup-python
+        uses: actions/setup-python@v3
+      - name: install black
+        run: pip install black
+      - name: lint
+        run: black --check .

backend/backend.py

@@ -0,0 +1,90 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from firebase_admin import credentials, messaging, initialize_app, auth
+import openai
+import uuid
+import asyncio
+
+app = FastAPI()
+
+# To store user information in memory.
+# WARNING: This information will be lost when the server stops/restarts
+user_data = {}
+
+
+class RegisterItem(BaseModel):
+    apiKey: str
+    authDomain: str
+    databaseURL: str
+    storageBucket: str
+    openai_key: str
+
+
+@app.post("/register")
+async def register(item: RegisterItem):
+    # Generate a unique user id
+    uid = str(uuid.uuid4())
+
+    # Initialize the Firebase app
+    user_data[uid] = {
+        "firebase": credentials.Certificate(
+            {
+                "apiKey": item.apiKey,
+                "authDomain": item.authDomain,
+                "databaseURL": item.databaseURL,
+                "storageBucket": item.storageBucket,
+            }
+        ),
+        "openai_key": item.openai_key,
+    }
+
+    initialize_app(user_data[uid]["firebase"], name=uid)
+
+    return {"uid": uid}
+
+
+class ProcessItem(BaseModel):
+    uid: str
+    prompt: str
+
+
+@app.post("/process_request")
+async def process_request(item: ProcessItem):
+    # Get the user data using the provided uid
+    user = user_data.get(item.uid)
+
+    if not user:
+        raise HTTPException(status_code=400, detail="Invalid uid")
+
+    # Set the OpenAI key for this user
+    openai.api_key = user["openai_key"]
+
+    # Call OpenAI
+    response = openai.Completion.create(
+        engine="text-davinci-002", prompt=item.prompt, max_tokens=150
+    )
+
+    # The message data that will be sent to the client
+    message = messaging.Message(
+        data={
+            "message": response.choices[0].text.strip(),
+        },
+        topic="updates",
+    )
+
+    # Send the message asynchronously
+    asyncio.run(send_notification(message, item.uid))
+
+    return {"message": "Notification sent"}
+
+
+def send_notification(message, uid):
+    # Send a message to the devices subscribed to the provided topic.
+    response = messaging.send(message, app=user_data[uid]["firebase"])
+    print("Successfully sent message:", response)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

backend/crappy_test.py

@@ -0,0 +1,33 @@
+import requests
+import json
+
+
+def test_register():
+    data = {
+        "apiKey": "test-api-key",
+        "authDomain": "test-auth-domain",
+        "databaseURL": "test-database-url",
+        "storageBucket": "test-storage-bucket",
+        "openai_key": "test-openai-key",
+    }
+    response = requests.post(
+        "http://localhost:8000/register",
+        data=json.dumps(data),
+        headers={"Content-Type": "application/json"},
+    )
+    assert response.status_code == 200
+    uid = response.json().get("uid")
+    assert uid is not None
+
+    # Let's use this uid to send a process request
+    data = {
+        "uid": uid,
+        "prompt": "Hello, OpenAI!",
+    }
+    response = requests.post(
+        "http://localhost:8000/process_request",
+        data=json.dumps(data),
+        headers={"Content-Type": "application/json"},
+    )
+    assert response.status_code == 200
+    assert response.json().get("message") == "Notification sent"

backend/requirements.txt

@@ -0,0 +1,10 @@
+pytest 
+requests
+fastapi
+firebase-admin
+gradio
+openai
+pinecone-io
+pydantic
+python-dotenv
+swagger-ui-bundle