def __init__(self, *args, **kwargs): self.key = "de504dc5763aeef9ff52" self.channels = {} self.messages = { "live_trades": ["trade"], "order_book": ["data"], "diff_order_book": ["data"], "live_orders": ["order_created", "order_changed", "order_deleted"] } for channel in self.messages.keys(): self.channels[channel] = [] for pair in ["btceur", "eurusd"]: self.channels[channel + "_" + pair] = [] self.orderbook = { "btc": { "eur": None, "usd": None }, "eur": { "usd": None } } self.lastprice = self.orderbook self.openorders = self.orderbook for base in self.openorders.keys(): for quote in self.openorders[base].keys(): self.openorders[base][quote] = {"price": {}, "id": {}} self.pusher = pusherclient.Pusher(self.key) self.pusher.connect()
def __init__(self, broker_id, username, password, websocket_url, bid_fee=0., ask_fee=0., api_key=None, api_secret=None, dest_market='BTCUSD'): self.api_key = api_key self.api_secret = api_secret self.bid_fee = bid_fee self.ask_fee = ask_fee self.broker_id = broker_id self.username = username self.password = password self.websocket_url = websocket_url self.pusher = pusherclient.Pusher(key='de504dc5763aeef9ff52', log_level=logging.ERROR) self.pusher.connection.bind('pusher:connection_established', self.on_bitstamp_connect_handler) self.pusher.connection.bind('pusher:connection_failed', self.on_bitstamp_connect_failed_handler) self.arbitrator = BlinkTradeArbitrator(self.broker_id, self.username, self.password, self.websocket_url, dest_market) self.arbitrator.signal_order.connect(self.on_send_order_to_bitstamp) self.arbitrator.signal_logged.connect(self.on_blinktrade_logged) self.arbitrator.signal_disconnected.connect( self.on_blinktrade_discconnected) self.arbitrator.signal_connected.connect(self.on_blinktrade_connected)
def __init__(self, ticker, *args, **kwargs): self.ticker = ticker self.pusher = pusherclient.Pusher(BTCUSDWorker.BITSTAMP_APP_KEY, log_level=logging.WARNING) self.pusher.connection.bind('pusher:connection_established', self.subscribe) self.pusher.connect()
def __init__(self, recent_trades): self.recent_trades = recent_trades self.logger = logging.getLogger('trades') self.client = pusherclient.Pusher(BITSTAMP_PUSHER_KEY) self.client.connection.bind('pusher:connection_established', self.on_connect) self.client.connect()
def __init__(self, bus): self.bus = bus with open(CLIENT_SECRETS_FILE) as data_file: data = json.load(data_file) self.p = pusherclient.Pusher(data['pusher']['key']) self.p.connection.bind('pusher:connection_established', self.connect_handler) self.p.connect()
def __init__(self, key, secret, channel_name, event_name, event_callback_function): self.channel_name = channel_name self.event_name = event_name self.event_callback_function = event_callback_function self.pusher = pusherclient.Pusher(key, secret) self.pusher.connection.bind('pusher:connection_established', self.connect_handler) self.pusher.connect()
def bitstamp_setup(): def connect_handler(data): channel = pusher.subscribe('live_trades') channel.bind('trade', bitstamp_callback) appkey = BITSTAMP_APPKEY pusher = pusherclient.Pusher(appkey) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect()
def __init__(self, log_file_path, log_file_reload_path, pusher_key, channel, event): self.channel = channel self.event = event self.log_file_fd = open(log_file_path, "a") self.log_file_reload_path = log_file_reload_path self.pusher = pusherclient.Pusher(pusher_key) self.pusher.connection.logger.setLevel(logging.WARNING) self.pusher.connection.bind('pusher:connection_established', self.connect_handler) self.pusher.connect()
def start(self): """ Extension of Pusher.connect() method, which registers all callbacks with the relevant channels, before initializing a connection. :return: """ super(BitstampWSS, self).start() self.pusher = pusherclient.Pusher(self.addr, **self.__pusher_options) self.pusher.connection.bind('pusher:connection_established', self._register_bindings) self.pusher.connect()
def start(self): def connect_handler(data): print("connect_handler") trades_channel = pusher.subscribe("live_trades") trades_channel.bind('trade', trade_callback) order_book_channel = pusher.subscribe('order_book') order_book_channel.bind('data', order_book_callback) pusher = pusherclient.Pusher("de504dc5763aeef9ff52") pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() self.pusher = pusher
def init(self, key, event, channel, symbol, depth, base, quote): self.event = event self.symbol = symbol self.depth = depth self.base = base self.quote = quote self.key = key if base == "btc" and quote == "usd": self.channel = channel else: self.channel = channel + "_" + self.symbol self.pusher = pusherclient.Pusher(self.key) self.pusher.connection.bind('pusher:connection_established', self.opened) self.pusher.connect()
def __init__(self, pusher_api_key, callback_chan, logger=None): """Constructor Arguments: pusher_api_key: the key to authenticate with pusher with callback_chan: the channel to use to receive callbacks """ self.logger = logger or logging.getLogger(__name__) self.pusher_connected_listeners = [] self.pos_callback_chan = callback_chan self.pusher = pusherclient.Pusher(pusher_api_key) self.pusher.connection.logger.setLevel(logging.WARNING) self.pusher.connection.bind('pusher:connection_established', self._pusher_connect_handler) self.pusher.connect() self.pusherthread_stop = Event() self.pusherthread = Thread(target=self._runForever, args=(self.pusherthread_stop, ))
def __call__(self): self._call_init() self.logger = logging.getLogger(self.__module__ + "." + self.__class__.__qualname__) self.pusher = pusherclient.Pusher(self.pusher_key, log_level=logging.WARNING) self.pusher.connection.bind('pusher:connection_established', self._connect_handler) self.pusher.connect() self.q = Queue() self.saver = Thread(target=self._saving_thread) self.saver.start() self.logger.info('Started') while not self.stop_flag.is_set(): time.sleep(1) self.saver.join() self.logger.info('Exit')
def hvacsettings_callback(data): # TODO - update hvac settings def hvactemp_callback(data): temp_data = json.loads(data) arduino.write('stmp' + json_data['temp']) def connect_handler(data): lights_channel = pusher.subscribe("lights") hvac_channel = pusher.subscribe("lights") lights_channel.bind('update_lights', lights_callback) hvac_channel.bind('update_settings', hvacsettings_callback) hvac_channel.bind('update_temp', hvacsettings_callback) if __name__ == '__main__': pusher = pusherclient.Pusher('bbfd2fdfc81124a36b18') pusher.connection.bind('pusher:connection_established', connect_handler) while True: time.sleep(1)
def __init__(self, *args, **kwargs): self.key = 'de504dc5763aeef9ff52' # Bitstamp pusher key. self.channels = {} self.messages = { 'live_trades': ['trade'], 'order_book': ['data'], 'diff_order_book': ['data'], 'live_orders': ['order_created', 'order_changed', 'order_deleted'] } self.lock = Lock() for channel in self.messages.keys(): self.channels[channel] = [] for pair in PAIRS: self.channels[channel + '_' + pair] = [] self.lastprice_btcusd = generate_response_template() self.lastprice_btceur = generate_response_template() self.lastprice_eurusd = generate_response_template() self.lastprice_xrpusd = generate_response_template() self.lastprice_xrpeur = generate_response_template() self.lastprice_xrpbtc = generate_response_template() self.lastprice_ltcusd = generate_response_template() self.lastprice_ltceur = generate_response_template() self.lastprice_ltcbtc = generate_response_template() self.lastprice_ethusd = generate_response_template() self.lastprice_etheur = generate_response_template() self.lastprice_ethbtc = generate_response_template() self.lastprice_bchusd = generate_response_template() self.lastprice_bcheur = generate_response_template() self.lastprice_bchbtc = generate_response_template() self.orderbook_btceur = generate_response_template() self.orderbook_btcusd = generate_response_template() self.openorders = generate_response_template() for base in self.openorders.keys(): for quote in self.openorders[base].keys(): self.openorders[base][quote] = {'price': {}, 'id': {}} self.pusher = pusherclient.Pusher(self.key) self.pusher.connect()
def main(): args = get_args() app = args.app[0] key = args.key[0] secret = args.secret[0] port = args.port[0] baud = args.baud[0] rx_channel, rx_event = args.rx_channel_event[0].split(':') tx_channel, tx_event = args.tx_channel_event[0].split(':') push = pusher.Pusher(app_id=app, key=key, secret=secret, ssl=True, port=443) push_client = pusherclient.Pusher(key, secret=secret) with PySerialDriver(port, baud) as driver: with Handler(Framer(driver.read, driver.write)) as handler: def push_it(sbp_msg): push.trigger(tx_channel, tx_event, sbp_msg.to_json_dict()) def pull_it(data): handler(SBP.from_json(data)) def connect_it(data): push_client.subscribe(rx_channel).bind(rx_event, pull_it) push_client.connection.bind('pusher:connection_established', connect_it) push_client.connect() try: for msg, metadata in handler.filter(OBS_MSG_LIST): push_it(msg) except KeyboardInterrupt: pass
""" def __init__(self): super(Transactions, self).__init__() self.source = 'https://www.bitstamp.net/api/transactions/?time=hour' self.update_interval = 60 class TransactionsBackup(ObjectSignal): """ Transactions Signal for Backup (Daily) """ def __init__(self): super(TransactionsBackup, self).__init__() self.source = 'https://www.bitstamp.net/api/transactions/?time=day' self.update_interval = 60 * 60 * 3 # Every 3 hours def connection_handler(data): global pusher order_book = pusher.subscribe('order_book') order_book.bind('data', OrderBook.update) live_trades = pusher.subscribe('live_trades') live_trades.bind('trade', Trades.update) pusher = pusherclient.Pusher('de504dc5763aeef9ff52', log_level=logging.WARNING) pusher.connection.bind('pusher:connection_established', connection_handler) pusher.connect()
bst_ticker['source'] = 'bst' bst_ticker['ask'] = float(ticker['asks'][0][0]) bst_ticker['bid'] = float(ticker['bids'][0][0]) bst_ticker['mid'] = round((bst_ticker['ask'] + bst_ticker['bid']) / 2, 2) bst_ticker['ts'] = time.time() bst = json.dumps(bst_ticker, ensure_ascii=False) print "BST: ", bst print r.set('bst', bst) print r.publish('bix-usd', bst) def connect_handler(data): channel = pusher.subscribe("order_book") channel.bind('data', channel_callback) if __name__ == '__main__': r = redis.StrictRedis(host='localhost', port=6379, db=0) appkey = 'de504dc5763aeef9ff52' pusher = pusherclient.Pusher(appkey) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() while True: time.sleep(0.1)
clientDatas = json.loads(data) if 'message' in data: print("Test successful!") def ping_handler(): print("pinging...") def run(): global serialNumber global clientData while True: # Do other things in the meantime here... print("Listening for " + str(serialNumber) + "...") print clientData time.sleep(2) initialize() pusher = pusherclient.Pusher("f3a6952cc326ee48eb10", True, "700363677ba4fd2d6f8c", {'cluster': 'eu'}, logging.INFO, True, None, 2) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() while True: # Do other things in the meantime here... print("Listening for " + str(serialNumber) + "...") print clientData time.sleep(2)
global pusher def print_usage(filename): print "Usage: python %s <appkey> <secret> <userid>" % filename def channel_callback(data): print "Channel Callback: %s" % data def connect_handler(data): channel = pusher.subscribe("presence-channel") channel.bind('my_event', channel_callback) if __name__ == '__main__': if len(sys.argv) != 4: print_usage(sys.argv[0]) sys.exit(1) appkey = sys.argv[1] secret = sys.argv[2] userid = sys.argv[3] pusher = pusherclient.Pusher(appkey, secret=secret, user_data={'user_id': userid}) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() while True: time.sleep(1)
def show_loading(): with canvas(device) as draw: draw.text((0, 0), "Awaiting a BTC trade...", font=font, fill="white") def main(): show_loading() while True: time.sleep(1) def handler(signum, frame): pusher.disconnect() sys.exit() pusher = pusherclient.Pusher(BITSTAMP_PUSHER_KEY) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() signal.signal(signal.SIGINT, handler) if __name__ == "__main__": try: serial = spi(device=0, port=0, cs_high=True) device = sh1106(serial) main() except KeyboardInterrupt: pass
def __init__(self, callback, *chans): self.pusher = pusherclient.Pusher(PUSHER_APP_KEY) self._callback = callback self._chans = chans
global pusher def garageEventCallback(data): print("Received an event") gic.startRecording(60) # We can't subscribe until we've connected, so we use a callback handler # to subscribe when able def connect_handler(data): channel = pusher.subscribe('robomow') channel.bind('garage-event', garageEventCallback) pusher = pusherclient.Pusher("dafdd16435b9b98c88fd") #pusher = pusherclient.Pusher("cc46da1883d0ec0a6197") pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() # # Manages detecting of the Robomow as it approaches or leaves the garage # the opening / closing of the garage door # the notification of events surrounding the garage class GarageInternalCamera(): #PUSHER_APP_ID = '487778' PUSHER_APP_ID = '489803' #PUSHER_KEY = 'cc46da1883d0ec0a6197' PUSHER_KEY = 'cc46da1883d0ec0a6197' #PUSHER_SECRET = 'cff575fc033daf5660a2'
asks_dict[asks_list[i]])) print(out_string) print() def connect_handler(data): channel = pusher.subscribe(pusherchannel) channel.bind(pusherevent, callback) logger = logging.getLogger() logger.setLevel(logging.INFO) log_stream_handler = logging.StreamHandler(Stream_Printer) logger.addHandler(log_stream_handler) pusher = pusherclient.Pusher(pusherkey) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() try: while True: time.sleep(1) except KeyboardInterrupt: print("\n\nKeyboard interrupt detected, exiting...\n") exit(0) except: exit(1) ### pusherclient code license ### ''' Copyright (c) 2011 Erik Kulyk
def __init__(self): self.pusher = pusherclient.Pusher('82341182465af8c47698', cluster='eu') self.pusher.connection.bind('pusher:connection_established', self.pusher_connected) self.pusher.connect()
import pusherclient # Import Homebrew # Add a logging handler so we can see the raw communication data import logging root = logging.getLogger() root.setLevel(logging.INFO) ch = logging.StreamHandler(sys.stdout) root.addHandler(ch) global pusher # We can't subscribe until we've connected, so we use a callback handler # to subscribe when able def connect_handler_BTCUSD(data): channel = pusher.subscribe('order_book') channel.bind('trade', callback) pusher = pusherclient.Pusher('de504dc5763aeef9ff52') pusher.connection.bind('pusher:connection_established', connect_handler_BTCUSD) pusher.connect() while True: # Do other things in the meantime here... time.sleep(1)
def pusher_server(): # SETTING THE CHANNEL AND EVENT TO TRIGGER EACH TIME event = 'App\Events\eventTrigger' channel = 'petfeed' # THE CALLBACK FUNCTION THAT WILL RUN AFTER EACH TRIGGER def callback_function(data): data = ast.literal_eval(data) # IF THE KEY GET HAS STATUS RETURN THE STATUS OF DEVICE if 'get' in data.keys(): with connection.cursor() as cursor: query = "SELECT DISTINCT id, email FROM users WHERE email=%s" try: cursor.execute(query, data['user']) user = cursor.fetchone() except: user = None if user is not None: if data['get'] == 'status': pusherEvent.trigger( channel, event, { 'connection': 'global', 'user': user['email'], 'message': 'Device is running perfectly fine.', 'status': 'online' }) elif data['get'] == 'schedule': with connection.cursor() as cursor: try: query = "SELECT * FROM schedules WHERE user_id=%s" cursor.execute(query, user['id']) schedules_result = cursor.fetchall() schedules = [] for s in schedules_result: scheduled_day = s['day'] scheduled_time = datetime.strftime( s['time'], "%H:%M") schedules.append({ "day": scheduled_day, "time": scheduled_time }) pusherEvent.trigger( channel, event, { 'connection': 'global', 'user': user['email'], 'data': schedules, 'status': 'Success' }) except: schedules = [] pusherEvent.trigger( channel, event, { 'connection': 'global', 'user': user['email'], 'data': schedules, 'status': 'error', 'message': 'Could not find schedules for specified user. (Schedules not set yet)' }) elif data['get'] == 'restart': pusherEvent.trigger( channel, event, { 'connection': 'global', 'user': user['email'], 'status': 'restarting', 'message': 'Restarting your device.' }) os.system('sudo restart') elif data['get'] == 'shutdown': pusherEvent.trigger( channel, event, { 'connection': 'global', 'user': user['email'], 'status': 'shuttingdown', 'message': 'Shutting down your device.' }) os.system('sudo shutdown') else: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'invalid get' }) else: pusherEvent.trigger( channel, event, { 'status': 'error', 'message': 'No device bound to the specified user.' }) # IF THE KEY FEED HAS THE VALUE FEED, FEED THE PET AND RETURN THE STATUS elif 'feed' in data.keys(): try: user = data['user'] with connection.cursor() as cursor: query = "SELECT DISTINCT id, email FROM users WHERE email=%s" cursor.execute(query, user) user_result = cursor.fetchone() if user_result is None: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'Specified user not registered to the device.' }) else: if data['feed'] == 'treat': pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'online', 'user': user_result['email'], 'message': 'Feeding your pet, please wait.' }) device_feed() pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'online', 'user': user_result['email'], 'message': 'Feeding completed successfully.' }) else: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'invalid value for feed:[]' }) except: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'The user field isn\'t set' }) elif 'set' in data.keys(): if data['set'] == 'schedule': try: user = data['user'] with connection.cursor() as cursor: query = "SELECT DISTINCT id, email FROM users WHERE email=%s" cursor.execute(query, user) user_result = cursor.fetchone() if user_result is None: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'Specified user not registered to the device.' }) else: if data['data'] is not None: for schedule in data['data']: day = schedule['day'] feed_time = schedule['time'] feed_time = datetime.strptime( feed_time, "%H:%M") sql = "INSERT INTO schedules (day, time, user_id) VALUES (%s, %s, %s)" cursor.execute( sql, (day, feed_time, user_result['id'])) connection.commit() pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'success', 'message': 'Your schedule was added successfully.' }) else: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'Empty data recieved.' }) except: with connection.cursor as cursor: cursor.rollback() pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'Internal error occurred while adding schedule' }) elif data['schedule'] == 'update': with connection.cursor() as cursor: try: user = data['user'] query = "SELECT DISTINCT id, email FROM users WHERE email=%s" cursor.execute(query, user) user_result = cursor.fetchone() if user_result is None: pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'Specified user not registered to the device.' }) else: query = "DELETE FROM schedules" cursor.execute(query) for schedule in data['data']: day = schedule['day'] feed_time = schedule['time'] feed_time = datetime.strptime( feed_time, "%H:%M") sql = "INSERT INTO schedules (day, time, user_id) VALUES (%s, %s, %s)" cursor.execute( sql, (day, feed_time, user_result['id'])) connection.commit() pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'success', 'message': 'Your schedule was updated successfully.' }) except: connection.rollback() pusherEvent.trigger( channel, event, { 'connection': 'global', 'status': 'error', 'message': 'Internal error occurred while updating schedule' }) def connect_handler(data): petfeed_channel = pusherClient.subscribe(channel) petfeed_channel.bind(event, callback_function) pusherClient = PusherClient.Pusher(key='0053280ec440a78036bc', secret='7bbae18dfe3989d432a6') pusherClient.connection.bind('pusher:connection_established', connect_handler) pusherClient.connect() pusherEvent = PusherEvent(app_id="440480", key="0053280ec440a78036bc", secret="7bbae18dfe3989d432a6", cluster="mt1") while True: time.sleep(1)
""" Changes: ------- Cluster: Added cluster in host name (also in process file arguments) Channel names, event names: Added chosen event names binding for given channel name - Added cluster<string> parameter (<Pusher>) > Added cluster in host name in <Pusher.__init__> > Removed <Pusher._build_url> @classmethod attribute - Added event_names<list> parameter (<Pusher>, <Connection>) > Added event_names binding in <Connection.__init__> @acknowledgement: Pysher (https://github.com/nlsdfnbch/Pysher/blob/master/pysher/pusher.py) @framework: Pusher (https://pusher.com/tutorials/chat-widget-python) """ event_names = [] for c in channel_names: event_names += channel_names[c][1].keys() pusher = pusherclient.Pusher(appkey, cluster=appcluster, event_names=event_names) pusher.connection.bind('pusher:connection_established', connect_handler) pusher.connect() print print '------------------------------------------------------------' print while True: time.sleep(1)
def __init__(self, channels=[]): self.channels = channels self.check_tradepair() self.currency = '' self.appkey = "de504dc5763aeef9ff52" self.pusher = pusherclient.Pusher(self.appkey)
import json import time import pusher import pusherclient app_key = 'a9afbec4cb2906a41792' def transaction_handler(data): tx = json.loads(data) print('Received transaction:') print('\tSend {} from {} to {} with payload {}.'.format( tx['value'], tx['from'], tx['to'], tx['message'])) def connect_handler(data): channel = listener.subscribe('transactions') channel.bind('new-transaction', transaction_handler) # HACK around library's lack of cluster support pusherclient.Pusher.host = "ws-eu.pusher.com" listener = pusherclient.Pusher(app_key) listener.connection.bind('pusher:connection_established', connect_handler) listener.connect() while True: time.sleep(1)