flask.ext.socketio.emit

Here are the examples of the python api flask.ext.socketio.emit taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

41 Examples 7

Example 1

Project: Pi-GPIO-Server Source File: sockets.py
@socketio.on('pin:write')
def pin_write(data):
    result = PIN_MANAGER.update_value(data['num'], data['value'])
    if not result:
        emit('pin:write', {'message': 'Pin not found'})
    else:
        response = PIN_MANAGER.read_one(data['num'])
        emit('pin:write', response)

Example 2

Project: flaskberry Source File: events.py
@socketio.on('register consumer', namespace=namespace)
def socket_register_player(data):
    status['consumers'] += 1
    join_room('consumers')
    session["is_player"] = True
    emit('play', status)
    emit_status()

Example 3

Project: RedruM Source File: events.py
@socketio.on('joined', namespace='/chat')
def joined(message):
    """Sent by clients when they enter a room.
    A status message is broadcast to all people in the room."""
    room = session.get('room')
    join_room(room)
    print "session1", session
    emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room)

Example 4

Project: RedruM Source File: events.py
@socketio.on('joinedsecondroom', namespace='/chat') 
def joinedsecondroom(message):
    room2 = session.get('room2')
    join_room(room2)
    print "session2", session
    emit('status2', {'msg': session.get('name') + ' has entered the room.'}, room=room2)

Example 5

Project: RedruM Source File: events.py
Function: left
@socketio.on('userinput', namespace='/chat')
def left(message):
    """Sent by a client when the user entered a new message.
    The message is sent to all people in the room."""
    room = session.get('room')
    emit('someonesaid', {'msg': session.get('name') + ':' + message['msg']}, room=room)

Example 6

Project: RedruM Source File: events.py
Function: left
@socketio.on('userinput2', namespace='/chat')
def left(message):
    """Sent by a client when the user entered a new message.
    The message is sent to all people in the room."""
    room2 = session.get('room2')
    emit('someonesaid2', {'msg': session.get('name') + ':' + message['msg']}, room=room2)

Example 7

Project: RedruM Source File: events.py
@socketio.on('left', namespace='/chat')
def left(message):
    """Sent by clients when they leave a room.
    A status message is broadcast to all people in the room."""
    room = session.get('room')
    leave_room(room)
    emit('status', {'msg': session.get('name') + ' has left the room.'}, room=room)

Example 8

Project: RedruM Source File: events.py
@socketio.on('left', namespace='/chat')
def left(message):
    """Sent by clients when they leave a room.
    A status message is broadcast to all people in the room."""
    room2 = session.get('room2')
    leave_room(room2)
    emit('status', {'msg': session.get('name') + ' has left the room.'}, room=room2)

Example 9

Project: utter-va Source File: sockethandlers.py
@socketio.on('connect', namespace='/utterio')
def connect():
	# build the response
	# response = {"response": "success", "result": {"message": "Sockets online.", "reload": False}}
  # emit response
	emit('message', {"data": "connected"})

Example 10

Project: WAPT Source File: app.py
Function: test_message
@socketio.on('my broadcast event', namespace='/test')
def test_message(message):
    session['receive_count'] = session.get('receive_count', 0) + 1
    emit('my response',
         {'data': message['data'], 'count': session['receive_count']},
         broadcast=True)

Example 11

Project: WAPT Source File: app.py
@socketio.on('join', namespace='/test')
def join(message):
    join_room(message['room'])
    session['receive_count'] = session.get('receive_count', 0) + 1
    emit('my response',
         {'data': 'In rooms: ' + ', '.join(request.namespace.rooms),
          'count': session['receive_count']})

Example 12

Project: WAPT Source File: app.py
@socketio.on('leave', namespace='/test')
def leave(message):
    leave_room(message['room'])
    session['receive_count'] = session.get('receive_count', 0) + 1
    emit('my response',
         {'data': 'In rooms: ' + ', '.join(request.namespace.rooms),
          'count': session['receive_count']})

Example 13

Project: WAPT Source File: app.py
Function: send_room_message
@socketio.on('my room event', namespace='/test')
def send_room_message(message):
    session['receive_count'] = session.get('receive_count', 0) + 1
    emit('my response',
        {'data': message['data'], 'count': session['receive_count']},
        room=message['room'])

Example 14

Project: cloud-asr Source File: run.py
@socketio.on('begin')
def begin_online_recognition(message):
    try:
        worker = create_frontend_worker(os.environ['MASTER_ADDR'])
        worker.connect_to_worker(message["model"])

        session["worker"] = worker
        session["connected"] = True
    except NoWorkerAvailableError:
        emit('server_error', {"status": "error", "message": "No worker available"})
        worker.close()

Example 15

Project: cloud-asr Source File: run.py
@socketio.on('chunk')
def recognize_chunk(message):
    try:
        if not session.get("connected", False):
            emit('server_error', {"status": "error", "message": "No worker available"})
            return

        results = session["worker"].recognize_chunk(message["chunk"], message["frame_rate"])
        for result in results:
            emit('result', result)
    except WorkerInternalError:
        emit('server_error', {"status": "error", "message": "Internal error"})
        session["worker"].close()
        del session["worker"]

Example 16

Project: cloud-asr Source File: run.py
@socketio.on('change_lm')
def change_lm(message):
    try:
        if not session.get("connected", False):
            emit('server_error', {"status": "error", "message": "No worker available"})
            return

        results = session["worker"].change_lm(str(message["new_lm"]))
        for result in results:
            emit('result', result)
    except WorkerInternalError:
        emit('server_error', {"status": "error", "message": "Internal error"})
        session["worker"].close()
        del session["worker"]

Example 17

Project: cloud-asr Source File: run.py
@socketio.on('end')
def end_recognition(message):
    if not session.get("connected", False):
        emit('server_error', {"status": "error", "message": "No worker available"})
        return

    results = session["worker"].end_recognition()
    for result in results:
        emit('result', result)

    emit('end', results[-1])

    session["worker"].close()
    session["connected"] = False
    del session["worker"]

Example 18

Project: python-hue Source File: server.py
Function: message
@socketio.on('update_light', namespace='/lights')
def message(message):
    print message
    h.lights[message["light"]].set_state(message["state"])

    h.get_state()
    emit('state', {'data': h.state}, broadcast=True)

Example 19

Project: flask-socketio-celery-example Source File: app.py
@socketio.on('connect', namespace='/events')
def events_connect():
    userid = str(uuid.uuid4())
    session['userid'] = userid
    current_app.clients[userid] = request.namespace
    emit('userid', {'userid': userid})
    emit('status', {'status': 'Connected user', 'userid': userid})

Example 20

Project: listentotwitter Source File: websocket.py
@socketio.on('ping')
def handle_ping(data):
    if not keyword_test(data['keyword']):
        return
    join_room(data['keyword'])
    result = keywordsmanager.ping_keyword(data['keyword'])

    if result:
        emit('keywords_synced', {'synced': True})

Example 21

Project: redispapa Source File: run.py
Function: exec_cmd
    def exec_cmd(self, *args):
        try:
            cmd_name = args[0].lower()
            if cmd_name == 'del':
                cmd_name = 'delete'
            cmd_method = getattr(self.client, cmd_name)
            result = cmd_method(*args[1:])
            if not result:
                result = 'None'
            emit('result', {'data': result, 'm_type': 'info'})
        except Exception as ex:
            emit('result', {'data': ex.message, 'm_type': 'error'})
            print '\033[93m %s \033[0m' % ex.message

Example 22

Project: redispapa Source File: run.py
@socketio.on('command_exec')
def client_command(message):
    args = message['args']
    args = tuple(args.split(','))
    cmd = message['command']
    args = (cmd,) + args
    r_server =  message['r_server']
    cmd_threads = [t for t in all_thread if '{0}:{1}'.format(t.host, t.port) == r_server]
    # print(cmd_threads)
    if cmd_threads:
        cmd_thread = cmd_threads[0]
        cmd_thread.exec_cmd(*args)
    else:
        emit('result', {'data': 'I can not find the redis server'})

Example 23

Project: Pi-GPIO-Server Source File: sockets.py
@socketio.on('pin:list')
def pin_list():
    response = PIN_MANAGER.read_all()
    emit('pin:list', response)

Example 24

Project: Pi-GPIO-Server Source File: sockets.py
@socketio.on('pin:read')
def pin_read(data):
    response = PIN_MANAGER.read_one(data['num'])
    emit('pin:read', response)

Example 25

Project: flaskberry Source File: events.py
@socketio.on('play', namespace=namespace)
def socket_play(data):
    emit('play', data, room='consumers')

Example 26

Project: flaskberry Source File: events.py
def emit_status():
    emit('status', status, broadcast=True)

Example 27

Project: RedruM Source File: events.py
@socketio.on('choosevictim', namespace='/chat')
def choosevictim(data):
    room = session.get('room')
    emit('status', {'msg': data['victim'] + ' has been eliminated'}, room=room)
    emit('eliminated', {'msg': data['victim']}, room=room)

Example 28

Project: WAPT Source File: app.py
Function: test_message
@socketio.on('my event', namespace='/test')
def test_message(message):
    session['receive_count'] = session.get('receive_count', 0) + 1
    emit('my response',
         {'data': message['data'], 'count': session['receive_count']})

Example 29

Project: WAPT Source File: app.py
Function: test_connect
@socketio.on('connect', namespace='/test')
def test_connect():
    emit('my response', {'data': 'Connected', 'count': 0})

Example 30

Project: WAPT Source File: test_socketio.py
Function: on_custom_event
@socketio.on('my custom event')
def on_custom_event(data):
    emit('my custom response', data)

Example 31

Project: WAPT Source File: test_socketio.py
@socketio.on('my custom namespace event', namespace='/test')
def on_custom_event_test(data):
    emit('my custom namespace response', data, namespace='/test')

Example 32

Project: WAPT Source File: test_socketio.py
@socketio.on('my custom broadcast event')
def on_custom_event_broadcast(data):
    emit('my custom response', data, broadcast=True)

Example 33

Project: WAPT Source File: test_socketio.py
@socketio.on('my custom broadcast namespace event', namespace='/test')
def on_custom_event_broadcast_test(data):
    emit('my custom namespace response', data, namespace='/test',
         broadcast=True)

Example 34

Project: WAPT Source File: test_socketio.py
@socketio.on('my room event')
def on_room_event(data):
    room = data.pop('room')
    emit('my room response', data, room=room)

Example 35

Project: deepy Source File: server.py
Function: test_action
@socketio.on('act', namespace='/test')
def test_action(message):
    action = agent.action(message['state'])
    emit('act', {'action': action})

Example 36

Project: WatchPeopleCode Source File: views.py
@socketio.on('join', namespace='/chat')
def join(streamer_username):
    streamer = check_chat_access_and_get_streamer(streamer_username)
    if streamer is None:
        request.namespace.disconnect()
    else:
        join_room(streamer.reddit_username)
        if current_user.is_authenticated():
            emit('join', False, session['username'])  # Sending the username before actual join.
        old_messages = []
        for msg in reversed(ChatMessage.query.filter_by(streamer=streamer).order_by(ChatMessage.id.desc()).limit(20).all()):
            if msg.text == "/clear":
                old_messages = []
            else:
                old_messages.append(msg)
        emit('last_messages',
             [{"sender": msg.sender,
               "text": nl2br_py(msg.text)}
              for msg in old_messages])
        emit('join', True, session['username'])
    db.session.close()

Example 37

Project: WatchPeopleCode Source File: views.py
@socketio.on('message', namespace='/chat')
def chat_message(message_text, streamer_username):
    streamer = check_chat_access_and_get_streamer(streamer_username)
    if len(message_text) > 2048:
        message_text = u"{}... <message is too big>".format(message_text[:2048])
    message = {"sender": session['username'],
               "text": nl2br_py(message_text)}
    if current_user.is_anonymous() and\
            streamer.streams.filter_by(type='wpc_stream').one().chat_anon_forbidden:
        emit("forbidden")
    elif current_user.is_authenticated() and current_user.is_banned:
        emit("message", message)
    else:
        if message_text.startswith("/clear"):
            if current_user.is_authenticated() and current_user.reddit_username == streamer.reddit_username:
                emit("clear", room=streamer.reddit_username)  # Clear for all viewers
                clear_message = ChatMessage(streamer=streamer, text="/clear", sender=session["username"])
                db.session.add(clear_message)
                db.session.commit()
            else:
                emit("clear")  # Clear for one user
        else:
            # Normal chat message
            cm = ChatMessage(streamer=streamer, text=message_text, sender=session['username'])
            db.session.add(cm)
            db.session.commit()
            emit("message", message, room=streamer.reddit_username)
    db.session.close()
    return True

Example 38

Project: python-hue Source File: server.py
Function: connect
@socketio.on('connect', namespace='/lights')
def connect():
    print message
    h.get_state()
    emit('state', {'data': h.state}, broadcast=True)

Example 39

Project: flask-socketio-celery-example Source File: app.py
@socketio.on('status', namespace='/events')
def events_message(message):
    emit('status', {'status': message['status']})

Example 40

Project: flask-socketio-celery-example Source File: app.py
Function: disconnect_request
@socketio.on('disconnect request', namespace='/events')
def disconnect_request():
    emit('status', {'status': 'Disconnected!'})
    disconnect()

Example 41

Project: redispapa Source File: run.py
@socketio.on('event')
def client_message(message):
    servers = [':'.join(s.split(':')[:2]) for s in REDIS_SERVER]
    emit('servers', {'data': servers})