49 votes

Bibliothèque client Socket.IO en Python

Quelqu'un peut-il recommander une bibliothèque client Socket.IO pour Python ? J'ai cherché un peu, mais les seules que j'ai trouvées sont soit des implémentations de serveur, soit dépendantes d'un framework tel que Twisted.

J'ai besoin d'une bibliothèque client qui ne dépend pas d'autres frameworks.

Il ne suffit pas d'utiliser l'un des nombreux types de connexion, car le client python devra travailler avec plusieurs serveurs socketio, dont beaucoup ne prennent pas en charge les websockets, par exemple.

42voto

rmanna Points 632

La réponse d'Archie1986 était bonne mais est devenue obsolète avec les mises à jour de socketio (plus précisément, son protocole : https://github.com/LearnBoost/socket.io-spec )... pour autant que je sache, vous devez effectuer le handshake manuellement avant de pouvoir demander une connexion de transport (par exemple, websockets)... notez que le code ci-dessous est incomplet et non sécurisé... d'une part, il ignore la liste des transports supportés renvoyée dans la réponse du handshake et essaie toujours d'obtenir une websocket... d'autre part, il suppose que le handshake réussit toujours... néanmoins, c'est un bon point de départ

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)

....

vous pouvez également vous documenter sur python-websockets : https://github.com/mtah/python-websocket

25voto

Archie1986 Points 695

Tout d'abord, je ne sais pas pourquoi certains de vos serveurs Socket.IO ne prennent pas en charge les websockets... L'objectif de Socket.IO est de faciliter le développement d'applications Web dans le navigateur frontal en fournissant une interface abstraite aux flux de données en temps réel servis par le serveur Socket.IO. Peut-être que Socket.IO n'est pas ce que vous devriez utiliser pour votre application ? Ceci mis à part, laissez-moi essayer de répondre à votre question...

À l'heure actuelle, il n'existe pas de bibliothèque client Socket.IO pour Python (gevent-socketio n'est pas une bibliothèque Socket.IO). client pour Python... c'est une bibliothèque Socket.IO serveur pour Python). Pour l'instant, vous allez devoir composer un code original afin de vous interfacer directement avec Socket.IO en tant que client tout en acceptant différents types de connexion.

Je sais que vous cherchez une panacée qui fonctionne avec différents types de connexion (WebSocket, long-polling, etc.), mais comme une telle bibliothèque n'existe pas encore, je peux au moins vous donner quelques conseils sur l'utilisation du type de connexion WebSocket en me basant sur mon expérience.

Pour le type de connexion WebSocket, créez un client WebSocket en Python. À partir de la ligne de commande, installez ce paquetage Python WebSocket Client aquí avec pip pour qu'il soit sur votre chemin python comme ceci :

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

Une fois que vous avez fait cela, essayez ce qui suit, en remplaçant SOCKET_IO_HOST y SOCKET_IO_PORT avec l'emplacement approprié de votre serveur 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)

À ce stade, vous disposez d'un moyen d'interagir avec un serveur Socket.IO directement depuis Python. Pour envoyer des messages au serveur Socket.IO, il suffit d'envoyer un message via cette connexion WebSocket. Pour que le serveur Socket.IO interprète correctement les messages entrants de votre client Python Socket.IO via cette WebSocket, vous devez respecter le protocole Socket.IO et coder toutes les chaînes ou dictionnaires que vous pourriez envoyer via la connexion WebSocket. Par exemple, après avoir accompli tout ce qui précède, faites ce qui suit :

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)

22voto

Roy Hyunjin Han Points 1246

El socketIO-client supporte les callbacks et les canaux d'évènements grâce au travail des contributeurs et est disponible sur PyPI sous la licence MIT.

Émission avec rappel.

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)

Définir les événements.

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)

Définir les événements dans un espace de nom.

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)

Définir différents espaces de noms sur un seul socket.

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)

5voto

Sushant Khurana Points 487

El SocketTornad.IO avec la populaire bibliothèque asynchrone Serveur Web Tornado est également l'une des options disponibles pour python.

4voto

Amit Upadhyay Points 116

J'en ai écrit un : https://github.com/amitu/amitu-websocket-client/blob/master/amitu/socketio_client.py . Il ne prend en charge que les websockets et peut donc n'avoir qu'une utilité marginale pour vous.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X