How to use the channels.generic.websocket.WebsocketConsumer function in channels

def callback(attr: str, old: Any, new: Any) -> None:
        if new == 1:
            data['y'] = [0, 10, 20, 30, 40, 50]
        else:
            data['y'] = [i * new for i in [0, 10, 20, 30, 40, 50]]
        source.data = ColumnDataSource(data=data).data
        plot.y_range.end = max(data['y'])

    slider = Slider(start=1, end=5, value=1, step=1, title="Test App Bokeh + Channels Controller")
    slider.on_change("value", callback)

    doc.add_root(column(slider, plot))


class TestWS(WebsocketConsumer):
    def connect(self):
        self.accept()

    def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['client_message']

        self.send(text_data=json.dumps({
            'server_message': message
        }))

    def disconnect(self, close_code):
        pass

self.accept()

    def receive(self, text_data=None, bytes_data=None):
        self.send(text_data=text_data, bytes_data=bytes_data)


class ErrorWebsocketApp(WebsocketConsumer):
    """
    Barebones WebSocket ASGI app for error testing.
    """

    def receive(self, text_data=None, bytes_data=None):
        pass


class KwargsWebSocketApp(WebsocketConsumer):
    """
    WebSocket ASGI app used for testing the kwargs arguments in the url_route.
    """

    def connect(self):
        self.accept()
        self.send(text_data=self.scope["url_route"]["kwargs"]["message"])


@pytest.mark.asyncio
async def test_websocket_communicator():
    """
    Tests that the WebSocket communicator class works at a basic level.
    """
    communicator = WebsocketCommunicator(SimpleWebsocketApp, "/testws/")
    # Test connection

import json
from json import JSONDecodeError

from channels.generic.websocket import WebsocketConsumer


class PingPong(WebsocketConsumer):
    """
    Replies with a 'Pong' for every 'Ping' and a 'Ping' for every 'Pong'
    """

    def connect(self):
        """
        Process the connection request sent by a socket instance
        """

        self.accept()

    def disconnect(self, _):
        """
        Process the disconnection of a socket instance
        :param _: the code indicating the reason for disconnection
        """

def state_dict(self):
        """Returns a dictionary containing all state of this class."""
        raise NotImplementedError()

    def get_state(self, _request):
        """Returns the state of this class as a json dictionary for clients to use."""
        state = self.state_dict()
        return JsonResponse(state)

    def update_state(self):
        """Sends an update event to all connected clients."""
        send_state_event(self.state_dict())


class StateConsumer(WebsocketConsumer):
    """Handles connections with websocket clients."""

    def connect(self):
        async_to_sync(self.channel_layer.group_add)("state", self.channel_name)
        self.accept()

    def disconnect(self, code):
        async_to_sync(self.channel_layer.group_discard)("state", self.channel_name)

    def receive(self, text_data=None, bytes_data=None):
        pass

    # Receive message from room group
    def state_update(self, event):
        """Receives a message from the room group and sends it back to the websocke."""
        # Send message to WebSocket

import json

from asgiref.sync import async_to_sync
from channels.generic.websocket import SyncConsumer, WebsocketConsumer


class PrintConsumer(SyncConsumer):

    def test_print(self, message):
        async_to_sync(self.channel_layer.group_send)(
            "stream", {"type": "stream.message", 'message': message})


class StreamConsumer(WebsocketConsumer):
    def connect(self):
        self.room_group_name = 'stream'

        # Join room group
        async_to_sync(self.channel_layer.group_add)(
            self.room_group_name,
            self.channel_name
        )

        self.accept()


    def disconnect(self, close_code):
        pass

    def receive(self, text_data):

on_command_started=self.handle_command_started,
            on_command_finished=self.handle_command_finished,
        )

    def receive(self, text_data=None, bytes_data=None):
        super().receive(text_data=text_data, bytes_data=bytes_data)
        self.audio_lifecycle.extend_audio(bytes_data)

    def handle_command_started(self):
        self.send_status(constants.EXPECTING_COMMAND)

    def handle_command_finished(self):
        self.send_status(constants.EXPECTING_WAKEWORD)


class AlexaConsumer(LifecycleMixin, AlexaClientMixin, WebsocketConsumer):

    dialog_request_id = None

    def receive(self, text_data=None, bytes_data=None):
        if text_data == 'ExpectSpeech':
            self.audio_lifecycle.handle_command_started(None)
        else:
            super().receive(text_data=text_data, bytes_data=bytes_data)

    def send_status(self, message_id):
        self.send(text_data=json.dumps({'type': message_id}))

    def handle_command_started(self, wakeword_name):
        super().handle_command_started()
        thr = threading.Thread(target=self.send_command_to_avs)
        thr.start()

import json

from asgiref.sync import async_to_sync
from channels.generic.websocket import WebsocketConsumer


class LinoConsumer(WebsocketConsumer):
    def connect(self):
        self.accept()
        if self.scope.get('user', False):
            username = self.scope["user"].username
            async_to_sync(self.channel_layer.group_add)(username, self.channel_name)

    def disconnect(self, close_code):
        pass

    def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        self.send(text_data=json.dumps({
            'message': message
        }))

import json, time, ast, uuid
from asgiref.sync import async_to_sync
from channels.generic.websocket import WebsocketConsumer
from dao.cicd import AppsManage
from libs.ansible.runner import ANSRunner
from utils.logger import logger
from cicd.models import *
from dao.redisdb import DsRedis
from service.cicd.deploy import DeployRunner

def format_time(seconds):
    m, s = divmod(seconds, 60)
    h, m = divmod(m, 60)  
    return "%02d:%02d:%02d" % (h, m, s)  

class AppsDeploy(WebsocketConsumer):
    def __init__(self, *args, **kwargs):
        super(AppsDeploy, self).__init__(*args, **kwargs) 
        self.stime = int(time.time())  
    
  
    def connect(self):
        self.project = self.get_apps(self.scope['url_route']['kwargs']['id'])
        
        if self.project:
            self.group_name = self.scope['url_route']['kwargs']['group_name']
            
            async_to_sync(self.channel_layer.group_add)(self.group_name, self.channel_name)
 
            self.accept()            
        else:
            self.close()

import json
from collections import deque
from django.conf import settings
from projs.tasks import deploy_log
from conf.logger import deploy_logger
from projs.models import ProjectConfig
from utils.db.redis_ops import RedisOps
from projs.utils.git_tools import GitTools
from projs.utils.svn_tools import SVNTools
from ansible.plugins.callback import CallbackBase
from task.utils import ansible_api_v2, gen_resource
from channels.generic.websocket import WebsocketConsumer
from projs.utils.deploy_notice import deploy_mail, deploy_wx


class DeployConsumer(WebsocketConsumer):

    def __init__(self, *args, **kwargs):
        super(DeployConsumer, self).__init__(*args, **kwargs)
        self.redis_instance = RedisOps(settings.REDIS_HOST, settings.REDIS_PORT, 5)
        self.deploy_results = []
        self.host_fail = []
        self.config = None
        self.d_type = None
        self.release_name = None
        self.release_desc = None
        self.host_list = None
        self.branch_tag = None

    def connect(self):
        self.accept()

#pylint: disable=no-member
from channels.generic.websocket import WebsocketConsumer, SyncConsumer
from channels.layers import get_channel_layer
from asgiref.sync import async_to_sync
from django.shortcuts import render, get_object_or_404, redirect, reverse
import urllib
from . import models
import json
import time


class InvoiceConsumer(WebsocketConsumer):
    def connect(self):
        self.invoice_id = self.scope["url_route"]["kwargs"]["invoice"]
        self.invoice = get_object_or_404(models.Invoice, id=self.invoice_id)
        async_to_sync(self.channel_layer.group_add)(
            self.invoice_id, self.channel_name)
        self.accept()

    def disconnect(self, close_code):
        async_to_sync(self.channel_layer.group_discard)(
            self.invoice_id, self.channel_name)

    def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']

        self.send(text_data=json.dumps({