I want to run my WSGI server in django using python socketio

[hetvaghasia39]

Getting this error when http api getting called, i.e. wsgi requests.

(.venv) het@het-GF63-Thin-10UC:~/het-workspace/infiniti_talks(dev)$ daphne -b 0.0.0.0 -p 8002 infinity_talks.asgi:application
2024-02-27 16:41:48,537 INFO     Starting server at tcp:port=8002:interface=0.0.0.0
2024-02-27 16:41:48,537 INFO     HTTP/2 support not enabled (install the http2 and tls Twisted extras)
2024-02-27 16:41:48,537 INFO     Configuring endpoint tcp:port=8002:interface=0.0.0.0
2024-02-27 16:41:48,538 INFO     Listening on TCP address 0.0.0.0:8002
2024-02-27 16:41:59,547 ERROR    Exception inside application: WSGIHandler.__call__() takes 3 positional arguments but 4 were given
Traceback (most recent call last):
  File "/home/het/het-workspace/infiniti_talks/.venv/lib/python3.12/site-packages/channels/routing.py", line 62, in __call__
    return await application(scope, receive, send)
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: WSGIHandler.__call__() takes 3 positional arguments but 4 were given
192.168.29.201:64054 - - [27/Feb/2024:16:41:59] "GET /listener/?search=&limit=15&startDate=&endDate=&page=1" 500 453

below is my asgi file

import os
import socketio
from channels.auth import AuthMiddlewareStack
from channels.routing import ProtocolTypeRouter, URLRouter
from django.core.asgi import get_asgi_application
from django.core.wsgi import get_wsgi_application

from apps.talks.routing import websocket_urlpatterns

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "infinity_talks.settings")

# Get the WSGI application
wsgi_application = get_wsgi_application()

# Get the ASGI application
asgi_application = get_asgi_application()

# Instantiate the Socket.IO server
sio = socketio.Server(async_mode='threading', cors_allowed_origins='*')

# Define WebSocket routing
websocket_routing = AuthMiddlewareStack(URLRouter(websocket_urlpatterns))

# Define the ASGI application
application = ProtocolTypeRouter({
    "http": wsgi_application,
    "websocket": websocket_routing,
})

# Define the combined WSGI and ASGI application
combined_application = socketio.WSGIApp(
    sio,
    wsgi_app=application
)

here is my consumer

from datetime import datetime
import os

import socketio
from asgiref.sync import sync_to_async
from socketio import AsyncNamespace


basedir = os.path.dirname(os.path.realpath(__file__))
async_mode = None
sio = socketio.Server(async_mode="threading", cors_allowed_origins="*")
thread = None

# sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
background_task_started = False


@sio.event
async def connect(sid, environ):
    try:
        print(f"WebSocket connected: {sid}")
        # await sio.emit("connect")
    except Exception as e:
        print(f"Error in connect event: {e}")

@sio.event
async def disconnect(sid):
    print(f"WebSocket disconnected: {sid}")

# class MainNamespace(AsyncNamespace):

@sio.on("*")
def test(sid, environ):
    print("test event")


@sio.event
async def joinChat(sid, data):
    """event for both customer and listener and joining the room"""
    try:
        print("joinChat event")
        customer_id = data.get("user_id")
        listener_id = data.get("listener_id")
        from apps.admin_panel.models import ChatRoom, User

        room = await sync_to_async(ChatRoom.objects.filter)(
            customer_id=customer_id, listener_id=listener_id
        )
        room = await sync_to_async(room.first)()

        if room:
            pass
        else:
            customer = await sync_to_async(User.objects.filter)(id=customer_id)
            customer = await sync_to_async(customer.first)()
            listener = await sync_to_async(User.objects.filter)(id=listener_id)
            listener = await sync_to_async(listener.first)()
            room = await sync_to_async(ChatRoom.objects.create)(
                customer_id=customer, listener_id=listener
            )

        await sio.enter_room(sid=sid, room=room.id)
        await sio.emit(
            "onJoinChatRequest",
            data={"status": True, "message": "success", "data": {"room": room.id}},
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def connectChat(sid, data):
    """for customer to check that listener is available for not"""
    try:
        print("connectChat event")
        customer_id = data.get("user_id")
        listener_id = data.get("listener_id")
        from apps.admin_panel.models import ChatRoom, ListenerDetail, User

        room = await sync_to_async(ChatRoom.objects.filter)(
            customer_id=customer_id, listener_id=listener_id
        )
        room = await sync_to_async(room.first)()
        customer = sync_to_async(User.objects.filter)(id=customer_id)
        customer = sync_to_async(customer.first)()
        listener = sync_to_async(ListenerDetail.objects.filter)(id=listener_id)
        listener = sync_to_async(listener.first)()
        if listener.is_busy:
            await sio.emit(
                "onChatConnectRequest",
                data={"status": True, "message": "Listener is busy", "data": None},
            )
        if not listener.is_available_for_chat:
            await sio.emit(
                "onChatConnectRequest",
                data={
                    "status": True,
                    "message": "Listener is not available",
                    "data": None,
                },
            )
        # send notification to listner's fcm token
        from apps.talks.utils.utilities import send_token_push

        send_token_push(
            title=f"{customer.first_name} {customer.last_name}",
            body=f"Chat request from {customer.first_name} {customer.last_name}",
            token=listener.user.fcm_token,
        )
        await sio.emit(
            "onChatConnectRequest",
            data={
                "status": True,
                "message": "Chat request sent to listener",
                "data": {"room": room.id},
            },
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def acceptChat(sid, data):
    """for listener to accept the request and after that joinChat will be emmited from client"""
    try:
        print("acceptChat event")
        customer_id = data.get("user_id")
        listener_id = data.get("listener_id")
        status = data.get("status")
        from apps.admin_panel.models import ChatRoom, Consultation, User

        room = await sync_to_async(ChatRoom.objects.filter)(
            customer_id=customer_id, listener_id=listener_id
        )
        room = await sync_to_async(room.first)()
        if status == "rejected":
            # send notification to user
            pass
        if status == "accepted":
            customer = await sync_to_async(User.objects.filter)(id=customer_id)
            listener = await sync_to_async(User.objects.update)(
                id=listener_id, is_busy=True
            )
            sync_to_async(Consultation.objects.create)(
                customer=customer, listener=listener, type="chat", status="accepted"
            )

        await sio.emit(
            "onAcceptChatRequest",
            data={
                "status": True,
                "message": "success",
                "data": {
                    "rate": listener.rate,
                    "is_busy": listener.is_busy,
                    "type": "chat",
                    "room": room.id,
                },
            },
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def onMessage(sid, data):
    """on message, event for both customer and listener"""
    try:
        room_id = data.get("room_id")
        sender_id = data.get("sender_id")
        receiver_id = data.get("receiver_id")
        consultation_id = data.get("consultation_id")
        message = data.get("message")
        from apps.admin_panel.models import (
            ChatMessage,
            ChatRoom,
            Consultation,
            User,
        )

        room = await sync_to_async(ChatRoom.objects.filter)(id=room_id)
        room = await sync_to_async(room.first)()
        sender = await sync_to_async(User.objects.filter)(id=sender_id)
        receiver = await sync_to_async(User.objects.filter)(id=receiver_id)
        consultation = await sync_to_async(Consultation.objects.filter)(
            id=consultation_id
        )
        message = await sync_to_async(ChatMessage.objects.create)(
            room=room,
            sender=sender,
            receiver=receiver,
            consultation=consultation,
            message=message,
        )

        await sio.emit(
            "onMessageRequest",
            data={
                "status": True,
                "message": "success",
                "data": {
                    "room": room.id,
                    "sender": sender_id,
                    "receiver": receiver_id,
                    "consultation": consultation_id,
                    "message": message,
                    "created_at": message.created_at,
                },
            },
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def onPauseChat(sid, data):
    """for both if user removes app from background"""
    try:
        room_id = data.get("room_id")
        consultation_id = data.get("consultation_id")
        from apps.admin_panel.models import ChatRoom, Consultation

        room = await sync_to_async(ChatRoom.objects.filter)(id=room_id)
        room = await sync_to_async(room.first)()
        consultation = await sync_to_async(Consultation.objects.filter)(
            id=consultation_id
        )
        if not sync_to_async(consultation.exists)():
            await sio.emit(
                "onPauseChatRequest",
                data={
                    "status": False,
                    "message": "Consultation not found",
                    "data": None,
                },
            )
        consultation = await sync_to_async(Consultation.objects.update)(
            id=consultation_id, status="paused"
        )

        await sio.emit(
            "onPauseChatRequest",
            data={"status": True, "message": "Paused", "data": {"room_id": room.id}},
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def onResumeChat(sid, data):
    """for both if user get back to app"""
    try:
        room_id = data.get("room_id")
        consultation_id = data.get("consultation_id")
        from apps.admin_panel.models import ChatRoom, Consultation

        room = await sync_to_async(ChatRoom.objects.filter)(id=room_id)
        room = await sync_to_async(room.first)()
        consultation = await sync_to_async(Consultation.objects.filter)(
            id=consultation_id
        )
        if not sync_to_async(consultation.exists)():
            await sio.emit(
                "onPauseChatRequest",
                data={
                    "status": False,
                    "message": "Consultation not found",
                    "data": None,
                },
            )
        consultation = await sync_to_async(Consultation.objects.update)(
            id=consultation_id, status="resumed"
        )

        await sio.emit(
            "onResumeChatRequest",
            data={
                "status": True,
                "message": "Resumed",
                "data": {"room_id": room.id},
            },
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def leaveChat(sid, data):
    """for customer to leave chat"""
    try:
        consultaion_id = data.get("consultation_id")
        listener_id = data.get("listener_id")
        room_id = data.get("room_id")
        from apps.admin_panel.models import Consultation, User

        consultaion = await sync_to_async(Consultation.objects.filter)(
            id=consultaion_id
        )
        consultaion = await sync_to_async(consultaion.update)(
            status="completed", end_time=datetime.now(), amount=0
        )
        listener = await sync_to_async(User.objects.filter)(id=listener_id)
        listener = await sync_to_async(listener.update)(is_busy=False)
        sio.leave_room(sid=sid, room=room_id)
        await sio.emit(
            "onLeaveChatRequest",
            data={"status": True, "message": "success", "data": None},
        )
    except Exception as e:
        print("e: ", e)

@sio.event
async def getListener(sid, data):
    pass


# sio.register_namespace(MainNamespace("chat/"))

[miguelgrinberg]

You are using the WSGI adapter for your Socket.IO app. Shouldn't that be the ASGI one? Django is trying to call it as an ASGI app, not WSGI.