Socket.IO libreria client in Python [chiusa]

Question

Qualcuno può raccomandare una libreria client Socket.IO per Python? Ho dato un'occhiata in giro, ma gli unici che posso trovare sono o implementazioni di server, o dipendere da un quadro, come ritorto.

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

Semplicemente usando uno dei molti tipi di connessione non è sufficiente, come il client python sarà necessario lavorare con più server socketio, molti dei quali non sosterrà WebSockets, per esempio.

Answer 1

La 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 posso dire, è necessario eseguire manualmente la stretta di mano prima di poter chiedere un trasporto (ad esempio, WebSockets) collegamento .. . si noti che il codice qui sotto è incompleto e insicuro ... per uno, si ignora l'elenco dei trasporti supportati restituiti nella risposta stretta di mano e cerca sempre di ottenere un websocket ... anche esso presuppone che la stretta di mano riesce sempre ... comunque , è un buon posto per iniziare

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

Prima di tutto, io non sono sicuro perché alcuni dei vostri server Socket.IO non sosterrà WebSockets ... l'intento di Socket.IO è quello di rendere front-end di sviluppo del browser di applicazioni web più facile, fornendo un astratto interfaccia per dati in tempo reale flussi di essere servito dal server Socket.IO. Forse Socket.IO non è quello che si dovrebbe utilizzare per la vostra applicazione? A parte questo, vorrei provare a rispondere alla tua domanda ...

A questo punto nel tempo, non ci sono eventuali librerie client Socket.IO per Python (gevent-socketio non è un Socket.IO client libreria per Python ... si tratta di un Socket. IO server libreria per Python). Per il momento, si sta andando ad avere a mettere un po 'di codice originale insieme al fine di interfacciarsi con Socket.IO direttamente come client pur accettando i vari tipi di connessione.

Lo so siete alla ricerca di una panacea che funziona su diversi tipi di connessione (WebSocket, lungo polling, ecc), ma dal momento che una biblioteca di questo tipo non esiste come ancora, posso almeno dare alcune indicazioni sull'utilizzo del tipo di connessione WebSocket base alla mia esperienza.

Per il tipo di connessione WebSocket, creare un client WebSocket in Python. Dalla riga di comando installare questo pacchetto di Python WebSocket client qui 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 la posizione appropriata 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 i messaggi al server Socket.IO semplicemente inviare un messaggio attraverso questa connessione WebSocket. Affinché il server di Socket.IO di interpretare correttamente i messaggi in arrivo attraverso questo WebSocket dal client Python Socket.IO, è necessario aderire al protocollo Socket.IO e codificare eventuali stringhe o dizionari si potrebbe inviare attraverso la connessione WebSocket. Ad esempio, dopo che hai 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 3

Il socketIO-client callback supporti libreria eventi e canali grazie al lavoro di collaboratori ed è disponibile su PyPI sotto la licenza MIT.

Emit con callback.

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)

Answer 4

Il SocketTornad.IO libreria con l'asincrono popolare Tornado Web Server è anche una delle opzioni disponibili per Python.

Answer 5

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

Answer 6

Hai avuto uno sguardo a gevent-socketio ?

La speranza aiuta.