Update app.py

app.py

@@ -1,137 +1,117 @@
+import os
+import time
 import json
 import random
-import string
-import time
-#from typing import Any
-
+#import requests
+#from gevent import pywsgi
 import g4f
-from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+import uvicorn
 
-from g4f import ChatCompletion
-from loguru import logger
-from starlette.middleware.cors import CORSMiddleware
+from g4f import ChatCompletion, Provider
+#from contextlib import closing
 
+# Importa el módulo nest_asyncio
 import nest_asyncio
-import os # Importo el módulo os para usar la variable de entorno
 
+# Llama a la función nest_asyncio.apply
 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):
-    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": [
+    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': [
                 {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": response,
+                    'delta': {
+                        'content': ""
                     },
-                    "finish_reason": "stop",
+                    'index': 0,
+                    'finish_reason': None
                 }
-            ],
-            "usage": {
-                "prompt_tokens": None,
-                "completion_tokens": None,
-                "total_tokens": None,
-            },
+            ]
         }
 
-    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"
+        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)
 
-        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):
-    # Obtengo el valor de MAX_ATTEMPTS desde la variable de entorno o uso un valor por defecto de 10
-    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."
+        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')
+
+
 
+# if __name__ == '__main__':
+#     uvicorn.run("app:app", host=site_config['host'], port=site_config['port'])