Python WebSocketClient.run_forever方法代码示例

# 需要导入模块: from ws4py.client.threadedclient import WebSocketClient [as 别名]
# 或者: from ws4py.client.threadedclient.WebSocketClient import run_forever [as 别名]
 def waitForEvents(self):
     """
     Pause and do not exit.  Wait over events from the server.
     This is optional. You should not use this method in ipython notebook
     Event will get called anyway.
     """
     WebSocketClient.run_forever(self)

# 需要导入模块: from ws4py.client.threadedclient import WebSocketClient [as 别名]
# 或者: from ws4py.client.threadedclient.WebSocketClient import run_forever [as 别名]
class Client(object):
    def __init__(self, listener):
        self.listener = listener
        self._ws_url = 'wss://ws.bitso.com'
        self.ws_client = WebSocketClient(self._ws_url)
        self.ws_client.opened = self.listener.on_connect
        self.ws_client.received_message = self._received
        self.ws_client.closed = self._closed
        self.channels = []

    def connect(self, channels):
        self.channels = channels
        self.ws_client.opened = self._opened
        self.ws_client.connect()
        self.ws_client.run_forever()

    def close(self):
        self.ws_client.close()
        
    def _opened(self):
        for channel in self.channels:
            self.ws_client.send(json.dumps({ 'action': 'subscribe', 'book': 'btc_mxn', 'type': channel }))
        thread.start_new_thread(self._ping_server, ())
        self.listener.on_connect()

    def _received(self, m):
        #print m.data
        val = json.loads(m.data)
        obj = StreamUpdate(val)
        self.listener.on_update(obj)
        
    def _closed(self, code, reason):
        self.listener.on_close(code, reason)
        
    def _ping_server(self):
        while True:
            #keep-alive
            self.ws_client.send(PingControlMessage(u'ping'))
            time.sleep(20)

# 需要导入模块: from ws4py.client.threadedclient import WebSocketClient [as 别名]
# 或者: from ws4py.client.threadedclient.WebSocketClient import run_forever [as 别名]

#.........这里部分代码省略.........
            server = self._get_server(data.get('guild_id'))
            user_id = data['user']['id']
            member = utils.find(lambda m: m.id == user_id, server.members)
            if member is not None:
                user = data['user']
                member.name = user['username']
                member.discriminator = user['discriminator']
                member.avatar = user['avatar']
                member.roles = []
                # update the roles
                for role in server.roles:
                    if role.id in data['roles']:
                        member.roles.append(role)

                self._invoke_event('on_member_update', member)
        elif event == 'GUILD_CREATE':
            self._add_server(data)
            self._invoke_event('on_server_create', self.servers[-1])
        elif event == 'GUILD_DELETE':
            server = self._get_server(data.get('id'))
            self.servers.remove(server)
            self._invoke_event('on_server_delete', server)

    def _opened(self):
        log.info('Opened at {}'.format(int(time.time())))

    def _closed(self, code, reason=None):
        log.info('Closed with {} ("{}") at {}'.format(code, reason, int(time.time())))
        self._invoke_event('on_disconnect')

    def run(self):
        """Runs the client and allows it to receive messages and events."""
        log.info('Client is being run')
        self.ws.run_forever()

    @property
    def is_logged_in(self):
        """Returns True if the client is successfully logged in. False otherwise."""
        return self._is_logged_in

    def get_channel(self, id):
        """Returns a :class:`Channel` or :class:`PrivateChannel` with the following ID. If not found, returns None."""
        if id is None:
            return None

        for server in self.servers:
            for channel in server.channels:
                if channel.id == id:
                    return channel

        for pm in self.private_channels:
            if pm.id == id:
                return pm

    def start_private_message(self, user):
        """Starts a private message with the user. This allows you to :meth:`send_message` to it.

        Note that this method should rarely be called as :meth:`send_message` does it automatically.

        :param user: A :class:`User` to start the private message with.
        """
        if not isinstance(user, User):
            raise TypeError('user argument must be a User')

        payload = {
            'recipient_id': user.id

# 需要导入模块: from ws4py.client.threadedclient import WebSocketClient [as 别名]
# 或者: from ws4py.client.threadedclient.WebSocketClient import run_forever [as 别名]

#.........这里部分代码省略.........
                self.servers.append(Server(**guild))
                channels = [Channel(server=self.servers[-1], **channel) for channel in guild['channels']]
                self.servers[-1].channels = channels

            for pm in data.get('private_channels'):
                self.private_channels.append(PrivateChannel(id=pm['id'], user=User(**pm['recipient'])))

            # set the keep alive interval..
            self.ws.heartbeat_freq = data.get('heartbeat_interval')

            # we're all ready
            self.events['on_ready']()
        elif event == 'MESSAGE_CREATE':
            channel = self.get_channel(data.get('channel_id'))
            message = Message(channel=channel, **data)
            self.events['on_message'](message)
            self.messages.append(message)
        elif event == 'MESSAGE_DELETE':
            channel = self.get_channel(data.get('channel_id'))
            message_id = data.get('id')
            found = next((m for m in self.messages if m.id == message_id), None)
            if found is not None:
                self.events['on_message_delete'](found)
                self.messages.remove(found)

    def _opened(self):
        print('Opened!')

    def _closed(self, code, reason=None):
        print('closed with ', code, reason)

    def run(self):
        """Runs the client and allows it to receive messages and events."""
        self.ws.run_forever()

    @property
    def is_logged_in(self):
        """Returns True if the client is successfully logged in. False otherwise."""
        return self._is_logged_in

    def get_channel(self, id):
        """Returns a :class:`Channel` or :class:`PrivateChannel` with the following ID. If not found, returns None."""
        if id is None:
            return None

        for server in self.servers:
            for channel in server.channels:
                if channel.id == id:
                    return channel

        for pm in self.private_channels:
            if pm.id == id:
                return pm

    def start_private_message(self, user):
        """Starts a private message with the user. This allows you to :meth:`send_message` to it.

        Note that this method should rarely be called as :meth:`send_message` does it automatically.

        :param user: A :class:`User` to start the private message with.
        """
        if not isinstance(user, User):
            raise TypeError('user argument must be a User')

        payload = {
            'recipient_id': user.id

# 需要导入模块: from ws4py.client.threadedclient import WebSocketClient [as 别名]
# 或者: from ws4py.client.threadedclient.WebSocketClient import run_forever [as 别名]

#.........这里部分代码省略.........
            member = Member(deaf=False, mute=False, **data)
            server.members.append(member)
            self._invoke_event("on_member_join", member)
        elif event == "GUILD_MEMBER_REMOVE":
            server = self._get_server(data.get("guild_id"))
            user_id = data["user"]["id"]
            member = next((m for m in server.members if m.id == user_id), None)
            server.members.remove(member)
            self._invoke_event("on_member_remove", member)
        elif event == "TYPING_START":
            if self.events["on_member_typing"] == _null_event:
                return

            member = self._get_member(data["user_id"])
            channel = self._get_channel(data["channel_id"])
            timestamp = data["timestamp"]
            self._invoke_event("on_member_remove", member, channel, timestamp)
        # elif event == 'VOICE_STATE_UPDATE':
        #   pass
        # else:
        #    print("Unhandled event (%s)" % event)
        #    from pprint import pprint
        #    pprint(response)

    def _opened(self):
        print("Opened at {}".format(int(time.time())))

    def _closed(self, code, reason=None):
        print('Closed with {} ("{}") at {}'.format(code, reason, int(time.time())))
        self._invoke_event("on_disconnect")

    def run(self):
        """Runs the client and allows it to receive messages and events."""
        self.ws.run_forever()

    @property
    def is_logged_in(self):
        """Returns True if the client is successfully logged in. False otherwise."""
        return self._is_logged_in

    def get_channel(self, id):
        """Returns a :class:`Channel` or :class:`PrivateChannel` with the following ID. If not found, returns None."""
        if id is None:
            return None

        for server in self.servers:
            for channel in server.channels:
                if channel.id == id:
                    return channel

        for pm in self.private_channels:
            if pm.id == id:
                return pm

    def start_private_message(self, user):
        """Starts a private message with the user. This allows you to :meth:`send_message` to it.

        Note that this method should rarely be called as :meth:`send_message` does it automatically.

        :param user: A :class:`User` to start the private message with.
        """
        if not isinstance(user, User):
            raise TypeError("user argument must be a User")

        payload = {"recipient_id": user.id}