Rework for uvicorn

- Add backend test
- Add gradio interface

.github/workflows/backend_ci.yml

@@ -0,0 +1,23 @@
+name: Backend CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    defaults:
+      run:
+        working-directory: backend
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.4'
+          cache: 'pip'
+      - name: pip Install
+        run: pip install -r requirements.txt
+      - name: Test
+        run: pytest

backend/.gitignore

@@ -0,0 +1 @@
+__pycache__

backend/README.md

@@ -0,0 +1,14 @@
+# Backend for the puppet
+
+
+	This servers receives everything going on on the puppet. It can send requests to the puppet to do action. it uses openai as a llm currents
+
+# dev
+
+- (optional) Install virtualenv or equiv please
+- pip install -r requirements.txt
+- pytest
+
+# you can also run the test server with
+- uvicorn --host 0.0.0.0 --port 8000 backend:app --reload
+

backend/backend.py

@@ -2,13 +2,19 @@ from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from firebase_admin import credentials, messaging, initialize_app, auth
 import openai
-import uuid
 import asyncio
+import gradio as gr
+from fastapi.middleware.wsgi import WSGIMiddleware
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+from dotenv import load_dotenv
+
+load_dotenv()
+
 
 app = FastAPI()
 
-# To store user information in memory.
-# WARNING: This information will be lost when the server stops/restarts
+# User credentials will be stored in this dictionary
 user_data = {}
 
 
@@ -17,30 +23,26 @@ class RegisterItem(BaseModel):
     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,
+    # Firebase initialization with user-specific credentials
+    cred = credentials.Certificate(
+        {
+            "apiKey": item.apiKey,
+            "authDomain": item.authDomain,
+            "databaseURL": item.databaseURL,
+            "storageBucket": item.storageBucket,
+        }
+    )
+    firebase_app = initialize_app(cred, name=str(len(user_data)))
+    # Add the Firebase app and auth details to the user_data dictionary
+    user_data[str(len(user_data))] = {
+        "firebase_app": firebase_app,
+        "authDomain": item.authDomain,
     }
-
-    initialize_app(user_data[uid]["firebase"], name=uid)
-
-    return {"uid": uid}
+    return {"uid": str(len(user_data) - 1)}  # Return the user ID
 
 
 class ProcessItem(BaseModel):
@@ -50,15 +52,13 @@ class ProcessItem(BaseModel):
 
 @app.post("/process_request")
 async def process_request(item: ProcessItem):
-    # Get the user data using the provided uid
-    user = user_data.get(item.uid)
+    # Get the user's Firebase app from the user_data dictionary
+    firebase_app = user_data.get(item.uid, {}).get("firebase_app", None)
+    authDomain = user_data.get(item.uid, {}).get("authDomain", None)
 
-    if not user:
+    if not firebase_app or not authDomain:
         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
@@ -70,21 +70,75 @@ async def process_request(item: ProcessItem):
             "message": response.choices[0].text.strip(),
         },
         topic="updates",
+        app=firebase_app,  # Use the user-specific Firebase app
     )
 
     # Send the message asynchronously
-    asyncio.run(send_notification(message, item.uid))
+    asyncio.run(send_notification(message))
 
     return {"message": "Notification sent"}
 
 
-def send_notification(message, uid):
+def send_notification(message):
     # Send a message to the devices subscribed to the provided topic.
-    response = messaging.send(message, app=user_data[uid]["firebase"])
+    response = messaging.send(message)
     print("Successfully sent message:", response)
 
 
-if __name__ == "__main__":
-    import uvicorn
+def gradio_interface():
+    def register(apiKey, authDomain, databaseURL, storageBucket):
+        response = requests.post(
+            "http://localhost:8000/register",
+            json={
+                "apiKey": apiKey,
+                "authDomain": authDomain,
+                "databaseURL": databaseURL,
+                "storageBucket": storageBucket,
+            },
+        )
+        return response.json()
+
+    def process_request(uid, prompt):
+        response = requests.post(
+            "http://localhost:8000/process_request", json={"uid": uid, "prompt": prompt}
+        )
+        return response.json()
+
+    demo = gr.Interface(
+        fn=[register, process_request],
+        inputs=[
+            [
+                gr.inputs.Textbox(label="apiKey"),
+                gr.inputs.Textbox(label="authDomain"),
+                gr.inputs.Textbox(label="databaseURL"),
+                gr.inputs.Textbox(label="storageBucket"),
+            ],
+            [gr.inputs.Textbox(label="uid"), gr.inputs.Textbox(label="prompt")],
+        ],
+        outputs="json",
+        title="API Explorer",
+        description="Use this tool to make requests to the Register and Process Request APIs",
+    )
+    return demo
+
+
+def process_request_interface(uid, prompt):
+    item = ProcessItem(uid=uid, prompt=prompt)
+    response = process_request(item)
+    return response
+
+
+def get_gradle_interface():
+    return gr.Interface(
+        fn=process_request_interface,
+        inputs=[
+            gr.inputs.Textbox(label="UID", type="text"),
+            gr.inputs.Textbox(label="Prompt", type="text"),
+        ],
+        outputs="text",
+        title="OpenAI Text Generation",
+        description="Generate text using OpenAI's GPT-3 model.",
+    )
+
 
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+app = gr.mount_gradio_app(app, get_gradle_interface(), path="/")

backend/crappy_test.py

@@ -1,8 +1,15 @@
-import requests
+import time
+from fastapi.testclient import TestClient
+import pytest
 import json
+import backend
+import httpx
 
 
-def test_register():
+@pytest.mark.asyncio
+async def test_register():
+    client = TestClient(backend.app)
+
     data = {
         "apiKey": "test-api-key",
         "authDomain": "test-auth-domain",
@@ -10,24 +17,5 @@ def test_register():
         "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"
+    with pytest.raises(ValueError):
+        client.post("/register", json=data)

backend/requirements.txt

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