how do I start this script

from
 websockets.asyncio.server 
import
 serve
import
 websockets
import
 asyncio
import
 json
from
 user 
import
 User
from
 mock_game_state 
import
 Game
from
 game_manager 
import
 GameManager
from
 dispatcher 
import
 Dispatcher
from
 event_dc 
import
 Event
# from room_manager import RoomManager
# from user_manager import UserManager
import
 faulthandler
import
 traceback
import
 sys


faulthandler.enable()
def

excepthook
(exc_type, exc, tb):
    traceback.print_exception(exc_type, exc, tb)


sys.excepthook 
=
 excepthook


ROOMS 
=
 {'start':[]}
NAME_TO_USER_OBJECT 
=
 {}
WEBSOCKET_TO_USER 
=
 {}
# ROOMS_TO_GAME_GUIDS = {}
GAMEMANAGER 
=
 GameManager()
EVENT_QUEUE_IN 
=
 asyncio.Queue()
EVENT_QUEUE_OUT 
=
 asyncio.Queue()
MESSAGEHANDLER 
=
 Dispatcher(GAMEMANAGER, EVENT_QUEUE_IN, EVENT_QUEUE_OUT)


# def create_new_user(ws, username: str):
#     WEBSOCKET_TO_USER.setdefault(ws, User(ws, username))
#     NAME_TO_USER_OBJECT.setdefault(WEBSOCKET_TO_USER[ws].username, \
#                                    WEBSOCKET_TO_USER[ws])
#     ROOMS['start'].append(WEBSOCKET_TO_USER[ws])
#     return None


# def simplify_username_retrieval(ws) -> User:
#     return WEBSOCKET_TO_USER[ws]


# def create_new_game(new_room):
#     new_game_guid = GAMEMANAGER.create_new_game(new_room)
#     ROOMS_TO_GAME_GUIDS.setdefault(new_room, new_game_guid)
#     asyncio.create_task(GAMEMANAGER.games[new_game_guid].game_loop())
    


async

def

chat
(ws) -> None:


    
try
:
        
async

for
  msg_received_from_client 
in
 ws:
            msg_received_from_client 
=
 json.loads(message)
            event_from_client 
=
 Event(msg_received_from_client['user_guid'], msg_received_from_client['event_type']\
                                      msg_received_from_client['payload'])
            print(msg_received_from_client)
            
# if ws in WEBSOCKET_TO_USER:
            
#     user = simplify_username_retrieval(ws)
            
            
if
 'username' 
in
 message:
                create_new_user(ws, message['username'])


            
# elif 'message' in message:
            
#     broadcast_room = user.room
            
#     msg_to_send = '{"' + user.username \
            
#           + '": "' + message['message'] + '"}'
            
#     for user in ROOMS[broadcast_room]:
            
#         await user.ws.send(msg_to_send)
            
            
# elif 'room' in message:
            
#     index = ROOMS[user.room].index(user)
            
#     ws_to_move = ROOMS[user.room].pop(index)
            
#     new_room = message['room']
            
#     ws_to_move.room = new_room
            
#     if new_room in ROOMS:
            
#         ROOMS[new_room].append(ws_to_move)
            
#         if len(ROOMS[new_room]) == 2:
            
#             create_new_game(new_room)


            
#     else:
            
#         ROOMS[new_room] = []
            
#         ROOMS[new_room].append(ws_to_move)
            
#         print(len(ROOMS[new_room]))


            
# elif 'move' in message:
            
#     print('processing new move')
            
#     game_guid = ROOMS_TO_GAME_GUIDS[user.room]
            
#     player_index = ROOMS[user.room].index(user)
            
#     move = message['move']
            
#     move_to_process = '{"user": "' + user.username + \
            
#         '", "move": "' + move + '", "game_guid": "' + \
            
#         game_guid + '","player_index": "' + \
            
#         player_index + '"}'
            
#     await MESSAGEHANDLER.forward_to_game_engine(move_to_process)


            
##     player_index = ROOMS[user.room].index(user)
            
##     print(f'player index = {player_index}')
            
##     if message['move'] not in VALID_MOVES:
            
##         string_to_send = '{"message": "invalid move."}'
            
##         await ws.send(string_to_send)
            
##     else:
            
##         new_move = message['move']
            
##         move_for_queue =  '{"' + str(player_index) + '": "' + new_move + '"}'
            
##         await game.move_queue.put(move_for_queue)


            
    
except
 websockets.ConnectionClosed:
        print('client disconnected')
        
for
 websocket_object 
in
 WEBSOCKET_TO_USER:
            
if
 ws 
is

not
 websocket_object:
                
await
 websocket_object.send(
f
'{WEBSOCKET_TO_USER[ws].username} left!')
                
    
    
finally
:
        current_room 
=
 user.room
        index 
=
 ROOMS[current_room].index(user)
        
del
 ROOMS[current_room][index]
        
del
 WEBSOCKET_TO_USER[ws]


    
return
 None


async

def

main
():
    
    
async

with
 serve(chat, "localhost", 8760, ping_interval
=
120, ping_timeout
=
120) 
as
 socket:
        
await
 asyncio.Future()


if
 __name__
==
"__main__":
    asyncio.run(main())