Libreria client Socket.IO in Python

Question

Qualcuno può consigliare una libreria client Socket.IO per Python? Ho dato un'occhiata in giro, ma gli unici che riesco a trovare sono le implementazioni del server o dipendono da un framework come Twisted.

Ho bisogno di una libreria client che non abbia dipendenze da altri framework.

Utilizzare semplicemente uno dei molti tipi di connessione non è sufficiente, poiché il client python dovrà funzionare con più server socketio, molti dei quali non supporteranno i websocket, ad esempio.

Answer 1

risposta di Archie1986 era buono, ma è diventato obsoleto con socketio aggiornamenti (più precisamente, il suo protocollo: https://github.com/LearnBoost/socket.io-spec) ... per quanto ne posso dire , è necessario eseguire manualmente l'handshake prima di poter chiedere una connessione di trasporto (es. websockets) ... nota che il codice sottostante è incompleto e non sicuro ... per uno, ignora l'elenco dei trasporti supportati restituiti nell'handshake risposta e cerca sempre di ottenere un websocket ... inoltre si presuppone che la stretta di mano abbia sempre successo ...Tuttavia, è un buon punto di partenza

import websocket, httplib 

... 

''' 
    connect to the socketio server 

    1. perform the HTTP handshake 
    2. open a websocket connection ''' 
def connect(self) : 
    conn = httplib.HTTPConnection('localhost:8124') 
    conn.request('POST','/socket.io/1/') 
    resp = conn.getresponse() 
    hskey = resp.read().split(':')[0] 

    self._ws = websocket.WebSocket(
        'ws://localhost:8124/socket.io/1/websocket/'+hskey, 
        onopen = self._onopen, 
        onmessage = self._onmessage) 

.... 

si potrebbe anche voler leggere su python-WebSockets: https://github.com/mtah/python-websocket

Answer 2

Hai dato un'occhiata a gevent-socketio?

Spero che aiuti.

Answer 3

Prima di tutto, non sono sicuro del perché alcuni dei server Socket.IO non supportano i websocket ... l'intento di Socket.IO è quello di semplificare lo sviluppo del browser front-end delle app Web fornendo un interfaccia astratta ai flussi di dati in tempo reale serviti dal server Socket.IO. Forse Socket.IO non è quello che dovresti usare per la tua applicazione? A parte questo, vorrei provare a rispondere alla tua domanda ...

A questo punto nel tempo, non ci sono librerie client Socket.IO per Python (gevent-socketio non è un Socket.IO cliente libreria per Python ... è una libreria Socket.IO per Python). Per ora, dovrai mettere insieme del codice originale per interfacciarlo con Socket.IO direttamente come client mentre accetti vari tipi di connessione.

So che stai cercando una cura, tutto ciò che funziona attraverso vari tipi di connessione (WebSocket, polling lungo, ecc.), Ma dal momento che una libreria come questa non esiste ancora, posso almeno dare alcune indicazioni sull'utilizzo del tipo di connessione WebSocket in base alla mia esperienza.

Per il tipo di connessione WebSocket, creare un client WebSocket in Python. Dalla riga di comando installare questo pacchetto client Python WebSocket here con pip in modo che sia il vostro percorso pitone in questo modo:

pip install -e git+https://github.com/liris/websocket-client.git#egg=websocket

Una volta fatto che provare la seguente, sostituendo SOCKET_IO_HOST e SOCKET_IO_PORT con l'appropriato posizione del server Socket.IO:

import websocket 

SOCKET_IO_HOST = "127.0.0.1" 
SOCKET_IO_PORT = 8080 

socket_io_url = 'ws://' + SOCKET_IO_HOST + ':' + str(SOCKET_IO_PORT) + '/socket.io/websocket' 

ws = websocket.create_connection(socket_io_url) 

a questo punto si ha una media di interfacciarsi con un server Socket.IO direttamente da Python. Per inviare messaggi al server Socket.IO è sufficiente inviare un messaggio attraverso questa connessione WebSocket. Affinché il server Socket.IO interpreti correttamente i messaggi in arrivo tramite questo WebSocket dal client Python Socket.IO, è necessario rispettare il protocollo Socket.IO e codificare qualsiasi stringa o dizionario che è possibile inviare tramite la connessione WebSocket. Ad esempio, dopo aver compiuto tutto sopra effettuare le seguenti operazioni:

def encode_for_socketio(message): 
    """ 
    Encode 'message' string or dictionary to be able 
    to be transported via a Python WebSocket client to 
    a Socket.IO server (which is capable of receiving 
    WebSocket communications). This method taken from 
    gevent-socketio. 
    """ 
    MSG_FRAME = "~m~" 
    HEARTBEAT_FRAME = "~h~" 
    JSON_FRAME = "~j~" 

    if isinstance(message, basestring): 
      encoded_msg = message 
    elif isinstance(message, (object, dict)): 
      return encode_for_socketio(JSON_FRAME + json.dumps(message)) 
    else: 
      raise ValueError("Can't encode message.") 

    return MSG_FRAME + str(len(encoded_msg)) + MSG_FRAME + encoded_msg 

msg = "Hello, world!" 
msg = encode_for_socketio(msg) 
ws.send(msg) 

Answer 4

Ha scritto uno: https://github.com/amitu/amitu-websocket-client/blob/master/amitu/socketio_client.py. Supporta solo websocket quindi potrebbe avere solo un'utilità marginale per te.

Answer 5

La biblioteca SocketTornad.IO con il popolare asincrono Tornado Web Server è anche una delle opzioni disponibili per Python.

Answer 6

La libreria socketIO-client supporta callback e canali di eventi grazie al lavoro dei contributori ed è disponibile su PyPI sotto la licenza MIT.

Emetti con richiamata.

from socketIO_client import SocketIO 

def on_bbb_response(*args): 
    print 'on_bbb_response', args 

with SocketIO('localhost', 8000) as socketIO: 
    socketIO.emit('bbb', {'xxx': 'yyy'}, on_bbb_response) 
    socketIO.wait_for_callbacks(seconds=1) 

definire gli eventi.

from socketIO_client import SocketIO 

def on_aaa_response(*args): 
    print 'on_aaa_response', args 

socketIO = SocketIO('localhost', 8000) 
socketIO.on('aaa_response', on_aaa_response) 
socketIO.emit('aaa') 
socketIO.wait(seconds=1) 

definire gli eventi in uno spazio dei nomi.

from socketIO_client import SocketIO, BaseNamespace 

class Namespace(BaseNamespace): 

    def on_aaa_response(self, *args): 
     print 'on_aaa_response', args 
     self.emit('bbb') 

socketIO = SocketIO('localhost', 8000) 
socketIO.define(Namespace) 
socketIO.emit('aaa') 
socketIO.wait(seconds=1) 

Definire namespace diversi su un singolo zoccolo.

from socketIO_client import SocketIO, BaseNamespace 

class ChatNamespace(BaseNamespace): 

    def on_aaa_response(self, *args): 
     print 'on_aaa_response', args 

class NewsNamespace(BaseNamespace): 

    def on_aaa_response(self, *args): 
     print 'on_aaa_response', args 

socketIO = SocketIO('localhost', 8000) 
chatNamespace = socketIO.define(ChatNamespace, '/chat') 
newsNamespace = socketIO.define(NewsNamespace, '/news') 

chatNamespace.emit('aaa') 
newsNamespace.emit('aaa') 
socketIO.wait(seconds=1)