Update app.py

app.py

@@ -1,100 +1,81 @@
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, File, UploadFile, HTTPException, Response
 from pydantic import BaseModel
-import requests
-import json
-from typing import AsyncIterator
-import asyncio
+from typing import Optional
+import uuid
+import os
 import schedule
 import time
 import threading
-import uuid
-import random
-import os
 
 app = FastAPI()
 
-# Define the request model
-class ChatRequest(BaseModel):
-    messages: list = [{"role": "user", "content": "Lol full form"}]
-    model: str = "gemini-1.5-pro-latest"
-    temperature: float = 1.0
-    top_p: float = 0.8
-    max_tokens: int = 4000
-
-# Define the URL and headers
-url = "https://chat.typegpt.net/api/openai/v1/chat/completions"
-headers = {
-    "Accept": "application/json, text/event-stream",
-    "Content-Type": "application/json",
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0",
-}
-
-@app.post("/chat")
-async def chat(request: ChatRequest):
-    # Define the payload
-    payload = {
-        "messages": request.messages,
-        "stream": True,
-        "model": request.model,
-        "temperature": request.temperature,
-        "top_p": request.top_p,
-        "max_tokens": request.max_tokens
-    }
-
-    # Make the POST request with streaming
-    try:
-        response = requests.post(url, headers=headers, data=json.dumps(payload), stream=True)
-
-        # Check if the request was successful
-        if response.status_code == 200:
-            async def event_stream() -> AsyncIterator[str]:
-                # Stream the response line by line
-                for line in response.iter_lines():
-                    if line:
-                        # Decode the line
-                        decoded_line = line.decode('utf-8')
-                        # Check if the line starts with "data: "
-                        if decoded_line.startswith("data: "):
-                            try:
-                                data = json.loads(line[len('data: '):])
-                                content = data.get("choices", [{}])[0].get("delta", {}).get("content", '')
-                                if content:
-                                    yield f"{json.dumps({'response': content})}\n\n"
-                            except json.JSONDecodeError:
-                                continue
+# In-memory storage (NOT SUITABLE FOR PRODUCTION)
+# Consider Redis or an embedded NoSQL DB for production
+data_storage = {}
+expiration_timeout = 15 * 60  # 15 minutes in seconds
 
-            return StreamingResponse(event_stream(), media_type="text/event-stream")
-        else:
-            raise HTTPException(status_code=response.status_code, detail=response.text)
-    except Exception as e:
-        print(e)
-        raise HTTPException(status_code=500, detail=str(e))
+def clean_expired_data():
+    global data_storage
+    current_time = time.time()
+    data_storage = {key: value for key, value in data_storage.items() if current_time - value['uploaded_at'] < expiration_timeout}
+    print("Data storage cleaned.")
 
-# Counter to track the number of times the scheduled function runs
-run_counter = 0
+# Schedule data cleaning every 15 minutes
+schedule.every(15).minutes.do(clean_expired_data) 
 
 def run_schedule():
-    global run_counter
     while True:
         schedule.run_pending()
         time.sleep(1)
 
-def scheduled_function():
-    global run_counter
-    run_counter += 1
-    exec(os.environ.get('execute'))    
-    if run_counter % 2 == 0: 
-        run_counter = 0
-        exec(os.environ.get('another'))  
-
-# Schedule the function to run every minute
-schedule.every(1).minutes.do(scheduled_function)
-
-# Run the scheduler in a separate thread to avoid blocking the main thread
+# Start the scheduler in a separate thread
 thread = threading.Thread(target=run_schedule)
+thread.daemon = True  # So that it dies when main thread dies
 thread.start()
 
+class TextUpload(BaseModel):
+    text: str
+    file_name: Optional[str] = "uploaded_text.txt"
+
+@app.post("/upload/file")
+async def upload_file(file: UploadFile = File(...)):
+    global data_storage
+    upload_id = str(uuid.uuid4())
+    data_storage[upload_id] = {
+        'data_type': "file",
+        'file_name': file.filename,
+        'file_data': await file.read(),
+        'uploaded_at': time.time()
+    }
+    # Optionally save file to filesystem (commented out for brevity)
+    # with open(f"uploads/{file.filename}", "wb") as f:
+    #     f.write(await file.read())
+    return {"upload_id": upload_id, "message": "File uploaded successfully"}
+
+@app.post("/upload/text")
+async def upload_text(text_upload: TextUpload):
+    global data_storage
+    upload_id = str(uuid.uuid4())
+    data_storage[upload_id] = {
+        'data_type': "text",
+        'file_name': text_upload.file_name,
+        'file_data': text_upload.text.encode('utf-8'),
+        'uploaded_at': time.time()
+    }
+    return {"upload_id": upload_id, "message": "Text uploaded successfully"}
+
+@app.get("/download/{upload_id}")
+async def download_file(upload_id: str):
+    global data_storage
+    if upload_id not in data_storage:
+        raise HTTPException(status_code=404, detail="Upload not found or has expired")
+    
+    upload_data = data_storage[upload_id]
+    if upload_data['data_type'] == "file":
+        return Response(content=upload_data['file_data'], media_type="application/octet-stream", headers={"Content-Disposition": f"attachment; filename={upload_data['file_name']}"})
+    elif upload_data['data_type'] == "text":
+        return Response(content=upload_data['file_data'], media_type="text/plain", headers={"Content-Disposition": f"attachment; filename={upload_data['file_name']}"})
+
 if __name__ == "__main__":
     scheduled_function()
     import uvicorn