Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIHugging Face Arena Human Preference 55K

这是我Django里面的view里面的函数:async def aichat(request): if request.method == 'POST': try:…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Mistralopenhermes-2.5-mistral-7b’s answer.
  1. User

    这是我Django里面的view里面的函数:async def ai_chat(request): if request.method == 'POST': try: # 从前端获取发送者名称(用户名) sender = request.POST.get('sender') # 从前端获取用户输入 user_input = request.POST.get('message')

            # ---------如果都没有找到,进行大模型响应---------
            # 从前端传来的请求数据
            data = {'sender': sender, 'message': user_input}
    
            # 发送LLM请求
            ai_response = await sync_to_async(send_message_to_llm)(sender, data)
    
            print('ai_response:', ai_response)
            # json会自动去掉换行符代码
            # ai_response_json = ai_response.json()
            return JsonResponse({'type': 'llm', 'ai_response': ai_response})
        except Exception as error:
            return JsonResponse({'error': str(error)}, status=400)
    else:
        return JsonResponse({'error': '请求方法不支持'}, status=405)
    

    async def send_message_to_llm(sender, message): # Connect to the WebSocket server websocket_path = f"/ws/metasgo/{sender}/" websocket_url = f"ws://127.0.0.1:8000{websocket_path}"

    async with websockets.connect(websocket_url) as websocket:
        # Send message to the WebSocket server
        await websocket.send(json.dumps({'request_sender': sender, 'request_message': message}))
    
        # Wait for the WebSocket server's response
        response = await websocket.recv()
        response_data = json.loads(response)
        return response_data ,然后这是ConsumerGo的代码:from channels.generic.websocket import AsyncWebsocketConsumer
    

    import json

    parse_qs模块提供了在 URL 处理方面的实用工具,其中包括解析查询字符串的功能。

    from urllib.parse import parse_qs from asgiref.sync import sync_to_async

    from channels.db import database_sync_to_async

    一个消费者实例用于处理一个客户端的 WebSocket 连接。

    class ConsumerGo(AsyncWebsocketConsumer): async def connect(self): # 获得 WebSocket 的查询字符串 # ws://example.com/ws/some_path/?request_sender=123&request_message=helloworld # 在这个例子中,查询字符串是: request_sender=123&request_message=helloworld。 query_string = self.scope["query_string"].decode("utf-8")

        # 解析查询字符串
        # parse_qs 函数是urllib.parse模块中的一个函数,用于解析查询字符串,并返回一个包含参数和其值的字典。
        # 如:query_params: {'request_sender': ['wqj'], 'request_message': ['helloworld']}
        query_params = parse_qs(query_string)
    
        # 提取 request_sender 和 request_message
        request_sender = query_params.get("request_sender", [None])[0]
        request_message = query_params.get("request_message", [None])[0]
    
        # 构造用户特定的channel_name
        # 每个用户有一个独特的 self.channel_name 的目的是为了确保每个用户都有自己独立的通信通道。
        # 这个通道是通过 WebSocket 连接建立的,而这个连接是通过一个唯一的标识符来标识的,即 self.channel_name。
        # WebSocket 是一种全双工通信协议,允许服务器主动向客户端推送消息。每个客户端(用户)需要与服务器建立一个持久的连接。
        # 为了标识和区分不同的连接,需要给每个连接分配一个唯一的标识符,这就是 self.channel_name 的作用。
        self.channel_name = f"user_{request_sender}"
    
        # 直接从用户指定的通道名称构造频道群组名称,无需任何引用或转义。
        # 组名称只能包含字母数字、连字符、下划线或句点。因此,此示例代码对于包含其他字符的房间名称将失败。
        # 例如,如果channel_name是 "user_wqjx1s",那么群组名就是 "llm_user_wqjx1s"。
        self.group_name = f"llm_{self.channel_name}"
    
        # 连接建立时将当前连接添加到指定的通道群组中
        # self.channel_layer.group_add 是一个异步方法,用于将当前连接添加到指定的群组中。
        # 群组是一组具有相同名称的通道,可以作为一个单元发送消息。
        #   在Channels中,您可以使用群组将消息广播到多个使用者(已连接的客户端)。
        #   每个通道(WebSocket连接)可以是一个或多个群组的成员。
        #   向群组发送消息时,消息将发送到该群组的所有通道。
        await self.channel_layer.group_add(self.group_name, self.channel_name)
    
        # 接受 WebSocket 连接
        await self.accept()
    
    # 当 WebSocket 连接关闭时调用
    async def disconnect(self, close_code):
        # 在连接关闭时不执行任何操作,可以在此处进行清理工作
        # 从房间群组中移除连接
        await self.channel_layer.group_discard(self.group_name, self.channel_name)
    
    # @sync_to_async是Django Channels和ASGI框架提供的一个装饰器,它允许你在同步的上下文中调用异步函数。
    # 在异步编程中,有时候你可能希望在同步代码中调用异步函数,这时就可以使用@sync_to_async。
    @sync_to_async
    async def handle_message(self, text_data_json):
        request_sender = text_data_json["request_sender"]
        request_message = text_data_json["request_message"]
        return {"request_sender": request_sender, "request_message": request_message}
    
    # 当从 WebSocket 接收到消息时调用,text_data 是原始字符串格式的消息
    async def receive(self, text_data):
        # 将接收到的 JSON 格式的文本数据解析为 Python 字典
        text_data_json = json.loads(text_data)
    
        message = await self.handle_message(text_data_json)
    
        await self.channel_layer.group_send(
            self.group_name, {
                "type": "client.message",
                **message,
            }
        )
    
        # 从字典中提取发送消息的用户
        # request_sender = text_data_json["request_sender"]
        # 从字典中提取消息内容
        # request_message = text_data_json["request_message"]
    
        # 假设 client_channel 是客户端LLM大模型的通道名称
        # 将问题信息发送给客户端的LLM大模型
        # await self.channel_layer.group_send(
        #     self.group_name, {
        #         "type": "client.message",
        #         "request_sender": request_sender,
        #         "request_message": request_message,
        #     }
        # )
    
    # 从房间群组接收消息
    # 当有消息被广播到房间群组时,Channels 将调用具有相应事件类型的消费者类中的方法。
    # 在本例中,事件类型是 client.message,对应于 client_message() 方法。
    # 在 client_message 方法中,通过 self.send 方法将消息发送回给 WebSocket 连接。
    # 这样,消息就会通过 WebSocket 连接返回给客户端。
    async def client_message(self, event):
        await self.send(text_data=json.dumps(event))
    
    async def client_message2(self, event):
        # 提取从群组接收到的消息内容
        request_sender = event["request_sender"]
        request_message = event["request_message"]
    
        # 将消息发送到 WebSocket 连接
        await self.send(text_data=json.dumps({
            "request_sender": request_sender,
            "request_message": request_message,
        }))
    

    后端报错:TypeError: sync_to_async can only be applied to sync functions.

  2. Assistant

    错误信息 "TypeError: sync_to_async can only be applied to sync functions." 指出 sync_to_async 装饰器只能应用于同步函数,但是在您的代码中,它被错误地应用于一个异步函数。

    在你的 ConsumerGo 类中,你有一个 handle_message 方法,它被错误地标记为 @sync_to_async 并定义为异步:

    # 这样是错误的,因为handle_message定义为异步函数
    @sync_to_async
    async def handle_message(self, text_data_json):
        request_sender = text_data_json["request_sender"]
        request_message = text_data_json["request_message"]
        return {"request_sender": request_sender, "request_message": request_message}
    

    @sync_to_async 装饰器的目的是将同步函数转换为可以在异步代码中调用的异步版本。由于 handle_message 本来就是异步的,你不需要这个装饰器。相反,你应该直接调用这个异步函数。为了解决这个问题,你应该删除 @sync_to_async 装饰器,并保持 handle_message 为异步:

    # 正确的做法是直接定义异步函数
    async def handle_message(self, text_data_json):
        request_sender = text_data_json["request_sender"]
        request_message = text_data_json["request_message"]
        return {"request_sender": request_sender, "request_message": request_message}
    

    然后,在 receive 方法中,你可以直接调用这个异步方法,而不需要任何额外的装饰器:

    async def receive(self, text_data):
        # 将接收到的 JSON 格式的文本数据解析为 Python 字典
        text_data_json = json.loads(text_data)
    
        # 直接调用异步的 handle_message 方法
        message = await self.handle_message(text_data_json)
    
        # 然后发送消息
        await self.channel_layer.group_send(
            self.group_name, {
                "type": "client.message",
                **message,
            }
        )
    

    确保在整个代码库中,所有的异步函数都被直接调用,并且只有同步函数才被装饰为异步。这样做应该能解决你遇到的错误。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.