Пример #1
0
    def __init__(self, key, secret, channels=[], reconnect=True):
        # Disabbling logging.
        #        logger = logging.getLogger()
        #        logger.disabled = True

        # API credentials.
        self.api_credentials = json.loads('{}')
        self.api_credentials["apiKey"] = key
        self.api_credentials["apiSecret"] = secret

        # Socket parameters.
        self.socket = Socketcluster.socket(
            "wss://sc-02.coinigy.com/socketcluster/")
        self.socket.setreconnection(reconnect)
        self.channels = {}

        # Composing different channels.
        for c in channels:
            self.channels[c] = Channel()
            self.socket.onchannel(c, self.channels[c].on_channel_message)

        # Connecting to socket.
        self.socket.setBasicListener(self.onconnect, self.ondisconnect,
                                     self.onConnectError)
        self.socket.setAuthenticationListener(self.onSetAuthentication,
                                              self.onAuthentication)
    def __init__(self, key, secret, channels=[], reconnect=True):
        # Disabbling logging.
        logger = logging.getLogger()
        logger.disabled = True
        
        # API credentials.
        self.api_credentials = json.loads('{}')
        self.api_credentials["apiKey"] = key
        self.api_credentials["apiSecret"] = secret
        
        # Socket parameters.
        self.socket = Socketcluster.socket("wss://sc-02.coinigy.com/socketcluster/")
        self.socket.setreconnection(reconnect)

        self.pub = Publisher(channels)
        # Populates the channels dictionary with all the different channels instances as values.
        for c in channels:
            channel = Subscriber(c)
            self.pub.register(c, channel)
            self.socket.onchannel(c, self.onChannelMessage)
        
        # Connecting to socket.
        self.socket.setBasicListener(self.onconnect, self.ondisconnect, 
                                     self.onConnectError)
        self.socket.setAuthenticationListener(self.onSetAuthentication, 
                                              self.onAuthentication)
Пример #3
0
def init_socket():
    global socket
    socket = Socketcluster.socket("ws://69.64.32.172:3001/socketcluster/")
    socket.setBasicListener(onconnect, ondisconnect, onConnectError)
    socket.setdelay(2)
    socket.setreconnection(True)
    socket.connect()
Пример #4
0
def init_socket():
    global socket
    socket = Socketcluster.socket("ws://" + str(ip_server) + ":3001/socketcluster/")
    socket.setBasicListener(onconnect, ondisconnect, onConnectError)
    socket.setdelay(2)
    socket.setreconnection(True)
    socket.enablelogger(True)
    socket.connect()
Пример #5
0
 def connect_ws(self, post_connect_callback, channels):
     """
     Connect to a websocket
     :channels:  List of SockChannel instances
     """
     self.post_conn_cb = post_connect_callback
     self.channels = channels
     self.sock = Socketcluster.socket(self.wsendpoint)
     self.sock.setBasicListener(self.on_connect, self.on_connect_close,
                                self.on_connect_error)
     self.sock.setAuthenticationListener(self.on_set_auth, self.on_auth)
     self.sock.setreconnection(False)
     self.sock.connect()
     self.log.info(f"Started websocket, listening on {self.wsendpoint}")
Пример #6
0
    def connect_ws(self, post_connect_callback, channels, reconnect=False):
        """
        Connect to a websocket
        :channels:  List of SockChannel instances
        """
        self.post_conn_cb = post_connect_callback
        self.channels = channels
        self.wsendpoint = self.context["conf"]["endpoints"].get("websocket")

        # Skip connecting if we don't have any channels to listen to
        if not channels:
            return

        # Create socket, connect, setting callbacks along the way
        self.sock = Socketcluster.socket(self.wsendpoint)
        self.sock.setBasicListener(self._on_connect, self._on_connect_close,
                                   self._on_connect_error)
        self.sock.setAuthenticationListener(self._on_set_auth, self._on_auth)
        self.sock.setreconnection(reconnect)
        self.sock.connect()
Пример #7
0
    def connect(self,
                apiKey,
                apiSecret,
                wsURL='wss://sc-02.coinigy.com/socketcluster/'):
        # Connects to the Coinigy API websocket and initializes data stores
        self.logger.debug("Connecting Websocket")
        self.logger.info("Conecting to %s" % wsURL)
        self.apiKey = apiKey
        self.apiSecret = apiSecret
        self.bReadyToUse = False  # not yet authenticated
        self.bError = False  # no errors yet
        self.socket = Socketcluster.socket(wsURL)  # create socket connection

        # set basic event listeners
        self.socket.setBasicListener(self.__onconnect, self.__ondisconnect,
                                     self.__onconnecterror)
        # set authentication listeners
        self.socket.setAuthenticationListener(self.__onsetauthentication,
                                              self.__onauthentication)
        # initiate connecting sequence in a separate thread
        self.socketThread = threading.Thread(
            target=lambda: self.__socketClusterThread())
        self.socketThread.daemon = True
        self.socketThread.start()
        self.logger.info("Started thread")

        # wait for authentication
        conn_timeout = 50
        while (not self.bReadyToUse and conn_timeout and not self.bError):
            sleep(1)
            conn_timeout -= 1

        if (not conn_timeout or self.bError) and not self.bReadyToUse:
            self.logger.error("Couldn't get connected. Exiting")
            # self.exit()
            sys.exit(1)
Пример #8
0
def main():
    dir_path = os.path.dirname(os.path.realpath(__file__))
    config = util.get_config(os.path.join(dir_path, 'trade.conf'))
    db_session = setup_db(**config['database'])

    api_credentials = {
        'apiKey': config['coinigy']['api_key'],
        'apiSecret': config['coinigy']['api_secret'],
    }

    tasks = list()
    for symbol, options in config['symbols'].items():
        if options['monitor'] == '1':
            tasks.append(dict(exchange=options['exchange'], symbol=symbol))

    tick = Ticker(tasks, db_session, api_credentials)

    socket = Socketcluster.socket("wss://sc-02.coinigy.com/socketcluster/")
    socket.setBasicListener(tick.on_connect, tick.on_disconnect,
                            tick.on_connect_error)
    socket.setAuthenticationListener(tick.on_set_authentication,
                                     tick.on_authentication)
    socket.setreconnection(True)
    socket.connect()
Пример #9
0
def messsageack(key, object, ackmessage):
    logging.info("Got data " + object + " from key " + key)
    ackmessage("this is error", "this is data")


def ack(key, error, object):
    logging.info("Got ack data " + object + " and error " + error +
                 " and key is " + key)


def puback(channel, error, object):
    if error is '':
        logging.info("Publish sent successfully to channel " + channel)


def suback(channel, error, object):
    if error is '':
        logging.info("Subscribed successfully to channel " + channel)


if __name__ == "__main__":
    socket = Socketcluster.socket("ws://localhost:8000/socketcluster/")
    socket.setBasicListener(onconnect, ondisconnect, onConnectError)
    socket.setAuthenticationListener(onSetAuthentication, onAuthentication)
    socket.onack('ping', messsageack)
    # socket.enablelogging()
    # socket.on('yell', message)
    # socket.setreconnection(True)
    socket.connect()
    # socket.connect(sslopt={"cert_reqs": ssl.CERT_NONE})
Пример #10
0
def ondisconnect(socket):
    logging.info("on disconnect got called")


def onConnectError(socket, error):
    logging.info("On connect error got called")


def onSetAuthentication(socket, token):
    logging.info("Token received " + token)
    socket.setAuthtoken(token)


def onAuthentication(socket, isauthenticated):
    logging.info("Authenticated is " + str(isauthenticated))

    def ack(eventname, error, data):
        print("token is " + json.dumps(data, sort_keys=True))
        your_code_starts_here(socket)

    socket.emitack("auth", api_credentials, ack)


if __name__ == "__main__":
    socket = Socketcluster.socket("wss://sc-02.coinigy.com/socketcluster/")
    socket.setBasicListener(onconnect, ondisconnect, onConnectError)
    socket.setAuthenticationListener(onSetAuthentication, onAuthentication)
    socket.setreconnection(False)
    socket.connect()
Пример #11
0
def onconnect(socket):
    print('on connect')


def ondisconnect(socket):
    logging.info("on disconnect got called")


def onConnectError(socket, error):
    logging.info("On connect error got called")


if __name__ == "__main__":
    print(threading.activeCount())
    socket = Socketcluster.socket("ws://35.229.77.94:8000/socketcluster/")
    socket.setBasicListener(onconnect, ondisconnect, onConnectError)

    def threaded_function(args):
        socket.connect()

    thread = Thread(target=threaded_function, args=(2, ))
    thread.start()

    def predict_rgb_image(img):
        result = gesture_names[model.predict_classes(img)[0]]
        print(result)
        return (result)

    def predict_rgb_image_vgg(image):
        image = np.array(image, dtype='float32')