Bibliothèque cliente Socket.IO dans Python
Quelqu'un peut-il recommander une bibliothèque cliente Socket.IO pour Python? J'ai jeté un œil, mais les seuls que je peux trouver sont soit des implémentations de serveur, soit dépendent d'un framework tel que Twisted.
J'ai besoin d'une bibliothèque cliente qui ne dépend pas d'autres frameworks.
La simple utilisation d'un des nombreux types de connexion n'est pas suffisante, car le client python devra travailler avec plusieurs serveurs socketio, dont beaucoup ne prendront pas en charge les websockets, par exemple.
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 la poignée de main manuellement avant de pouvoir demander une connexion de transport (par exemple, des websockets) ... notez que le code ci-dessous est incomplet et non sécurisé ... pour sa part, il ignore la liste des transports pris en charge retournés dans la poignée de main réponse et essaie toujours d'obtenir une prise Web ... aussi cela suppose que la poignée de main réussit toujours ... néanmoins, c'est un bon endroit pour commencer
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 voudrez peut-être aussi lire sur python-websockets: https://github.com/mtah/python-websocket
Tout d'abord, je ne sais pas pourquoi certains de vos serveurs Socket.IO ne prendront pas en charge les websockets ... le but de Socket.IO est de faciliter le développement de navigateur frontal d'applications Web en fournissant une interface abstraite à de vrais de 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? Cela dit, permettez-moi d'essayer de répondre à votre question ...
À l'heure actuelle, il n'y a pas de bibliothèque client Socket.IO pour Python (gevent-socketio n'est pas un client Socket.IO bibliothèque pour Python ... c'est une bibliothèque serveur Socket.IO pour Python). Pour l'instant, vous allez avoir pour reconstituer du code original afin d'interfacer avec Socket.IO directement en tant que client tout en acceptant divers types de connexion.
Je sais que vous cherchez un remède universel qui fonctionne sur différents types de connexion (WebSocket, longue interrogation, etc.), mais comme une bibliothèque comme celle-ci n'existe pas encore, je peux au moins vous donner quelques conseils sur en utilisant le type de connexion WebSocket en fonction de mon expérience.
Pour le type de connexion WebSocket, créez un client WebSocket en Python. À partir de la ligne de commande, installez ce Python WebSocket Client package ici avec pip pour qu'il se trouve sur votre python chemin 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 et 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'interfaçage avec un serveur Socket.IO directement à partir de Python. Pour envoyer des messages au serveur Socket.IO, envoyez simplement un message via cette connexion WebSocket. Pour que le serveur Socket.IO interprète correctement les messages entrants via ce WebSocket à partir de votre client Python Socket.IO, vous devez adhérer au protocole Socket.IO et encoder toutes les chaînes ou dictionnaires que vous peut envoyer via la connexion WebSocket. Par exemple, après avoir accompli tout ce qui précède, procédez comme 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)
La bibliothèque socketIO-client prend en charge les rappels d'événements et les canaux grâce au travail des contributeurs et est disponible sur PyPI sous la licence MIT.
Émettre 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éfinissez 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éfinissez les événements dans un espace de noms.
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éfinissez différents espaces de noms sur un même 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)
Le SocketTornad.IO bibliothèque avec le populaire asynchrone serveur Web Tornado est également l'une des options disponibles pour python.
A écrit un: https://github.com/amitu/amitu-websocket-client/blob/master/amitu/socketio_client.py . Il ne prend en charge que les websockets, il ne peut donc avoir qu'un utilitaire marginal pour vous.
Avez-vous regardé gevent-socketio ?
J'espère que ça aide.