Spaces:
Running
Running
File size: 7,796 Bytes
26e1cfd 581b386 26e1cfd 581b386 26e1cfd 581b386 26e1cfd 581b386 26e1cfd 581b386 26e1cfd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 |
from fastapi import FastAPI, Request, staticfiles, Depends, HTTPException, status
from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
from fastapi.security import HTTPBasic, HTTPBasicCredentials
import os, json, re, requests
from datetime import datetime, timedelta
import time
import jwt
import openai
from openai import error as openai_error
from hashlib import sha256
import tiktoken
from supported import supp_langs
app = FastAPI()
security = HTTPBasic()
tokenizer = tiktoken.encoding_for_model("gpt-3.5-turbo")
app.mount("/static", staticfiles.StaticFiles(directory="static"), name="static")
users = json.loads(str(os.getenv("USER_KEYS")).replace("\n", ""))
for key in users:
if key == "master": continue
password = key+users[key]+users["master"]
users[key] = sha256(password.encode('UTF-8')).hexdigest()
def write_line(line):
with open("log.txt", "a") as f:
f.write(line)
f.write("\n")
def write_multi_line(list_text):
for line in list_text:
write_line(line)
write_line("---------------------------")
write_multi_line(["inicio"])
fecha_unix = str(int(time.time()))
JWT_SECRET = users["master"]
JWT_ALGORITHM = "HS256"
JWT_EXPIRATION_TIME_MINUTES = 30
def create_jwt_token(data):
to_encode = {"data": data}
expire = datetime.utcnow() + timedelta(minutes=JWT_EXPIRATION_TIME_MINUTES)
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, JWT_SECRET, algorithm=JWT_ALGORITHM)
return encoded_jwt
async def validate_token(request: Request):
data = {}
try:
data = await request.json()
token = data.pop("token")
payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
data["token_data"] = payload["data"]
except:
raise HTTPException(status_code=404, detail="Datos no v谩lidos")
return data
def authenticate_user(credentials: HTTPBasicCredentials):
password = credentials.username+credentials.password+users["master"]
password = sha256(password.encode('UTF-8')).hexdigest()
if credentials.username not in users or password != users[credentials.username]:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect username or password",
headers={"WWW-Authenticate": "Basic"},
)
return True
@app.get("/", response_class=HTMLResponse)
async def root(request: Request, credentials: HTTPBasicCredentials = Depends(security)):
if authenticate_user(credentials):
token = create_jwt_token({"user":credentials.username})
with open(os.path.join("static", "main.html")) as f:
return HTMLResponse(f.read().replace("{% token %}", token).replace("{% version %}", fecha_unix))
@app.get("/tabs", response_class=HTMLResponse)
async def root_tabs(request: Request, credentials: HTTPBasicCredentials = Depends(security)):
if authenticate_user(credentials):
token = create_jwt_token({"user":credentials.username})
with open(os.path.join("static", "main2.html")) as f:
return HTMLResponse(f.read().replace("{% token %}", token).replace("{% version %}", fecha_unix))
@app.post("/chat_stream")
async def chat_stream(data = Depends(validate_token)):
messages = data.get("messages", "")
if not messages:
print("Empty message")
error = "What??"
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail= error
)
try:
token_length = len(tokenizer.encode(messages[-1]["content"]))
except:
token_length = len(messages[-1]["content"])
print("Error in token length")
print("Message:", messages[-1]["content"])
config = {
"temperature": float(data.get("config", []).get("temperature", 1)),
"frequency_penalty": float(data.get("config", []).get("frequency_penalty", 1)),
"presence_penalty": float(data.get("config", []).get("presence_penalty", 1))
}
try:
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages,
temperature=config["temperature"],
frequency_penalty=config["frequency_penalty"],
presence_penalty=config["presence_penalty"],
request_timeout = 25,
stream=True
)
except requests.exceptions.RequestException as e:
print("Timeout (requests)")
print(e)
raise HTTPException(
status_code=status.HTTP_408_REQUEST_TIMEOUT,
detail="Los servidores tardaron mucho en responder, puede haber sobrecarga en OpenAI, reintenta luego (error 1)"
)
except openai_error.APIConnectionError as e:
print("APIConnectionError")
print(e)
raise HTTPException(
status_code=status.HTTP_408_REQUEST_TIMEOUT,
detail="El servidor no respondi贸, puede haber sobrecarga en OpenAI, reintenta luego (error 2)"
)
except openai_error.Timeout as e:
print("Timeout (openai)")
print(e)
raise HTTPException(
status_code=status.HTTP_408_REQUEST_TIMEOUT,
detail="El servidor no respondi贸, puede haber sobrecarga en OpenAI, reintenta luego (error 3)"
)
except openai_error.InvalidRequestError as e:
print("Timeout (openai)")
print(e)
error = "El servidor no respondi贸, puede haber sobrecarga en OpenAI, reintenta luego (error 3)"
if "This model's maximum context length is 4097 tokens" in e.message:
error = "ChatGPT se gomit贸 馃ぎ, limpia el chat y reintenta."
raise HTTPException(
status_code=status.HTTP_408_REQUEST_TIMEOUT,
detail= error
)
token = create_jwt_token(data.pop("token_data"))
async def __streamer():
yield json.dumps({"object": "chat.token", "token": token})
#yield json.dumps({"object": "chat.user.length", "length": token_length})
tokens = 0
for chunk in response:
tokens += 1
yield json.dumps(chunk)
#yield({"object": "chat.assistant.length", "length": tokens})
return StreamingResponse(__streamer(), media_type="application/json")
@app.get("/read_log", response_class=HTMLResponse)
async def read_log(request: Request, credentials: HTTPBasicCredentials = Depends(security)):
if authenticate_user(credentials):
with open("log.txt", "r") as f:
return HTMLResponse(f.read())
@app.get("/mfdfastapi")
async def webhook_get(request: Request):
write_multi_line([
"GET mfdfastapi:",
"headers: {}".format(json.dumps(dict(request.headers.items()))),
"params : {}".format(json.dumps(dict(request.query_params.items()))),
])
mode = request.query_params.get('hub.mode', "")
if mode=="subscribe":
challenge = request.query_params.get('hub.challenge', "")
verify_token = request.query_params.get('hub.verify_token', "")
if not mode or not challenge or not verify_token:
raise HTTPException(status_code=404, detail="Datos no v谩lidos")
if verify_token != users["master"]:
raise HTTPException(status_code=404, detail="Datos no v谩lidos")
return HTMLResponse(str(challenge))
@app.post("/mfdfastapi")
async def webhook_post(request: Request):
parametros_post = await request.json()
write_multi_line([
"POST mfdfastapi:",
"headers: {}".format(json.dumps(dict(request.headers.items()))),
"params : {}".format(json.dumps(dict(request.query_params.items()))),
"post : {}".format(json.dumps(parametros_post))
])
return HTMLResponse("ok")
|