Update app.py

app.py

@@ -1,117 +1,136 @@
-import os
-import time
 import json
 import random
-#import requests
-#from gevent import pywsgi
+import string
+import time
+# from typing import Any
+
 import g4f
-from fastapi import FastAPI, Request, Response
-from fastapi.responses import JSONResponse, StreamingResponse
-from fastapi.middleware.cors import CORSMiddleware
-import logging
-import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
 
 from g4f import ChatCompletion
-#from contextlib import closing
+from loguru import logger
+from starlette.middleware.cors import CORSMiddleware
 
-# Importa el módulo nest_asyncio
 import nest_asyncio
-g4f.debug.logging = True
+import os
 
 nest_asyncio.apply()
 
 app = FastAPI()
+
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
-LOG = logging.getLogger(__name__)
 
 
 @app.post("/chat/completions")
 @app.post("/v1/chat/completions")
-@app.post("/")
 async def chat_completions(request: Request):
-    data = await request.json()
-    streaming = data.get('stream', False)
-    model = data.get('model', 'gpt-4-32k')
-    messages = data.get('messages')
-
-    response = ChatCompletion.create(model=model, stream=streaming,
-                                     messages=messages, provider=g4f.Provider.Bing)
-
-    if not streaming:
-        while 'curl_cffi.requests.errors.RequestsError' in response:
-            response = ChatCompletion.create(model=model, stream=streaming,
-                                             messages=messages, provider=g4f.Provider.Bing)
-
-        completion_timestamp = int(time.time())
-        completion_id = ''.join(random.choices(
-            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
-
-        return JSONResponse({
-            'id': 'chatcmpl-%s' % completion_id,
-            'object': 'chat.completion',
-            'created': completion_timestamp,
-            'model': model,
-            'usage': {
-                'prompt_tokens': 0,
-                'completion_tokens': 0,
-                'total_tokens': 0
-            },
-            'choices': [{
-                'message': {
-                    'role': 'assistant',
-                    'content': response
-                },
-                'finish_reason': 'stop',
-                'index': 0
-            }]
-        })
-
-    def stream():
-        completion_data = {
-            'id': '',
-            'object': 'chat.completion.chunk',
-            'created': 0,
-            'model': 'gpt-4-32k',
-            'choices': [
+    req_data = await request.json()
+    stream = req_data.get("stream", False)
+    model = req_data.get("model", "gpt-3.5-turbo")
+    messages = req_data.get("messages")
+    temperature = req_data.get("temperature", 1.0)
+    top_p = req_data.get("top_p", 1.0)
+    max_tokens = req_data.get("max_tokens", 0)
+
+    logger.info(
+        f"chat_completions:  stream: {stream}, model: {model}, temperature: {temperature}, top_p: {top_p}, max_tokens: {max_tokens}"
+    )
+
+    response = await gen_resp(max_tokens, messages, model, stream, temperature, top_p)
+
+    completion_id = "".join(random.choices(string.ascii_letters + string.digits, k=28))
+    completion_timestamp = int(time.time())
+
+    if not stream:
+        logger.info(f"chat_completions:  response: {response}")
+        return {
+            "id": f"chatcmpl-{completion_id}",
+            "object": "chat.completion",
+            "created": completion_timestamp,
+            "model": model,
+            "choices": [
                 {
-                    'delta': {
-                        'content': ""
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": response,
                     },
-                    'index': 0,
-                    'finish_reason': None
+                    "finish_reason": "stop",
                 }
-            ]
+            ],
+            "usage": {
+                "prompt_tokens": None,
+                "completion_tokens": None,
+                "total_tokens": None,
+            },
         }
 
-        for token in response:
-            completion_id = ''.join(
-                random.choices('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789', k=28))
-            completion_timestamp = int(time.time())
-            completion_data['id'] = f'chatcmpl-{completion_id}'
-            completion_data['created'] = completion_timestamp
-            completion_data['choices'][0]['delta']['content'] = token
-            if token.startswith("an error occured"):
-                completion_data['choices'][0]['delta']['content'] = "Server Response Error, please try again.\n"
-                completion_data['choices'][0]['delta']['stop'] = "error"
-                yield 'data: %s\n\ndata: [DONE]\n\n' % json.dumps(completion_data, separators=(',' ':'))
-                return
-            yield 'data: %s\n\n' % json.dumps(completion_data, separators=(',' ':'))
-            time.sleep(0.1)
-
-        completion_data['choices'][0]['finish_reason'] = "stop"
-        completion_data['choices'][0]['delta']['content'] = ""
-        yield 'data: %s\n\n' % json.dumps(completion_data, separators=(',' ':'))
-        yield 'data: [DONE]\n\n'
-
-    return StreamingResponse(stream(), media_type='text/event-stream')
-
-
+    def streaming():
+        for chunk in response:
+            completion_data = {
+                "id": f"chatcmpl-{completion_id}",
+                "object": "chat.completion.chunk",
+                "created": completion_timestamp,
+                "model": model,
+                "choices": [
+                    {
+                        "index": 0,
+                        "delta": {
+                            "content": chunk,
+                        },
+                        "finish_reason": None,
+                    }
+                ],
+            }
+
+            content = json.dumps(completion_data, separators=(",", ":"))
+            yield f"data: {content}\n\n"
+            time.sleep(0)
+
+        end_completion_data: dict[str, Any] = {
+            "id": f"chatcmpl-{completion_id}",
+            "object": "chat.completion.chunk",
+            "created": completion_timestamp,
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": "stop",
+                }
+            ],
+        }
+        content = json.dumps(end_completion_data, separators=(",", ":"))
+        yield f"data: {content}\n\n"
+
+    return StreamingResponse(streaming(), media_type="text/event-stream")
+
+
+async def gen_resp(max_tokens, messages, model, stream, temperature, top_p):
+    MAX_ATTEMPTS = int(os.getenv("MAX_ATTEMPTS", 10))
+    attempts = 0
+    while True:
+        try:
+            response = ChatCompletion.create(
+                model=model,
+                stream=stream,
+                messages=messages,
+                temperature=temperature,
+                top_p=top_p,
+                max_tokens=max_tokens,
+                system_prompt="",
+                provider=g4f.Provider.Bing,
+            )
+            return response
+        except Exception as e:
+            logger.error(f"gen_resp:  Exception: {e}")
+            attempts += 1
+            if attempts >= MAX_ATTEMPTS:
+                return "Lo siento, no he podido generar una respuesta de chat. Por favor, revisa tu conexión a Internet y la configuración de la API y vuelve a intentarlo."
 
-# if __name__ == '__main__':
-#     uvicorn.run("app:app", host=site_config['host'], port=site_config['port'])