def setUp(self): super(TestChannelSubscription, self).setUp() messenger_config = pnconf_sub_copy() messenger_config.set_presence_timeout(8) messenger_config.uuid = "heartbeat-tornado-messenger" listener_config = pnconf_sub_copy() listener_config.uuid = "heartbeat-tornado-listener" self.pubnub = PubNubTornado(messenger_config, custom_ioloop=self.io_loop) self.pubnub_listener = PubNubTornado(listener_config, custom_ioloop=self.io_loop)
def setUp(self): AsyncTestCase.setUp(self) pnconf = PNConfiguration() pnconf.publish_key = 'demo' pnconf.subscribe_key = 'demo' pnconf.enable_subscribe = False self.pn = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
def test_publish_do_not_store(self): self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) self.assert_success( self.pubnub.publish().channel(ch).message("hey").should_store(False)) self.assert_success_yield( self.pubnub.publish().channel(ch).message("hey").should_store(False))
def test_super_call(self): ch1 = "state-tornado-ch1" ch2 = "state-tornado-ch2" pnconf = pnconf_pam_copy() pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) pubnub.config.uuid = 'test-state-tornado-uuid-|.*$' state = {"name": "Alex", "count": 5} env = yield pubnub.set_state() \ .channels([ch1, ch2]) \ .state(state) \ .future() assert env.result.state['name'] == "Alex" assert env.result.state['count'] == 5 env = yield pubnub.get_state() \ .channels([ch1, ch2]) \ .future() assert env.result.channels[ch1]['name'] == "Alex" assert env.result.channels[ch2]['name'] == "Alex" assert env.result.channels[ch1]['count'] == 5 assert env.result.channels[ch2]['count'] == 5 pubnub.stop() self.stop()
def test_error_non_serializable(self): self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) def method(): pass self.assert_client_side_error(self.pubnub.publish().channel(ch).message(method), "not JSON serializable")
def test_publish_with_meta(self): self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) self.assert_success( self.pubnub.publish().channel(ch).message("hey").meta({'a': 2, 'b': 'qwer'})) self.assert_success_yield( self.pubnub.publish().channel(ch).message("hey").meta({'a': 2, 'b': 'qwer'}))
def sfd_process(sfd): FX_CHANNEL = "lightning_ticker_FX_BTC_JPY" BTC_CHANNEL = "lightning_ticker_BTC_JPY" class BitflyerSubscriberCallback(SubscribeCallback): def message(self, pubnub, message): tick = message.message timestamp = dateutil.parser.parse(tick["timestamp"]) with sfd.lock: changed = False if message.channel == FX_CHANNEL: if sfd.fx_ltp != tick["ltp"]: sfd.fx_ltp = tick["ltp"] changed = True elif message.channel == BTC_CHANNEL: if sfd.btc_ltp != tick["ltp"]: sfd.btc_ltp = tick["ltp"] changed = True if sfd.ready and changed: sfd.disparity = (sfd.fx_ltp / sfd.btc_ltp) * 100 - 100 if (sfd.fx_ltp > sfd.btc_ltp and sfd.disparity >= 10.0) or \ (sfd.fx_ltp < sfd.btc_ltp and sfd.disparity <= -10.0): sfd.last_sfd_at = timestamp sfd.updated_at = timestamp sfd.event.set() config = PNConfiguration() config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' config.reconnect_policy = PNReconnectionPolicy.LINEAR config.ssl = False config.set_presence_timeout(60) pubnub = PubNubTornado(config) listener = BitflyerSubscriberCallback() pubnub.add_listener(listener) pubnub.subscribe().channels([FX_CHANNEL, BTC_CHANNEL]).execute() pubnub.start()
def test_publish_futurex(self): pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) envelope = yield pubnub.publish().message('hey').channel( 'blah').future() assert isinstance(envelope, TornadoEnvelope) assert not envelope.is_error() pubnub.stop()
def test_publish_future_raises(self): pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop) e = yield pubnub.publish().message('hey').channel('blah').future() assert isinstance(e, PubNubTornadoException) assert e.is_error() assert 400 == e.value()._status_code pubnub.stop()
def test_publish_result_raises_pubnub_error(self): pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop) with pytest.raises(PubNubException) as exinfo: yield pubnub.publish().message('hey').channel('blah').result() assert 'Invalid Subscribe Key' in str(exinfo.value) assert 400 == exinfo.value._status_code pubnub.stop()
def test_error_invalid_key(self): conf = PNConfiguration() conf.publish_key = "fake" conf.subscribe_key = "demo" self.pubnub = PubNubTornado(conf, custom_ioloop=self.io_loop) self.assert_server_side_error(self.pubnub.publish().channel(ch).message("hey"), "Invalid Key") self.assert_server_side_error_yield(self.pubnub.publish().channel(ch).message("hey"), "Invalid Key")
def test_error_not_permitted_403(self): my_pnconf = pnconf_pam_copy() my_pnconf.secret_key = None self.pubnub = PubNubTornado(my_pnconf, custom_ioloop=self.io_loop) self.assert_server_side_error( self.pubnub.publish().channel("not_permitted_channel").message("hey"), "HTTP Client Error (403)") self.assert_server_side_error_yield( self.pubnub.publish().channel("not_permitted_channel").message("hey"), "HTTP Client Error (403)")
def __init__(self, fxevents, tick_interval): self.fxevents = fxevents self.tick_interval = tick_interval self.instruments = 'lightning_ticker_BTC_JPY' config = PNConfiguration() config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' config.reconnect_policy = PNReconnectionPolicy.LINEAR self.pubnub = PubNubTornado(config) self.run = True
def xtest_publish_future_raises_lower_level_error(self): pubnub = PubNubTornado(corrupted_keys, custom_ioloop=self.io_loop) pubnub.http.close() e = yield pubnub.publish().message('hey').channel('blah').future() assert isinstance(e, PubNubTornadoException) assert str(e) == "fetch() called on closed AsyncHTTPClient" pubnub.stop()
def __init__(self): super().__init__() self.c = PNConfiguration() self.c.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' self.c.reconnect_policy = PNReconnectionPolicy.LINEAR self.pubnub = PubNubTornado(self.c) channels = [ self.realtime_product, ] self.main(channels) self.pubnub.start()
def xtest_publish_result_raises_lower_level_error(self): pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) # TODO: find a better way ot emulate broken connection pubnub.http.close() with self.assertRaises(Exception) as context: yield pubnub.publish().message('hey').channel('blah').result() assert 'fetch() called on closed AsyncHTTPClient' in str( context.exception.message) pubnub.stop()
def test_publish_ssl(self): print(sys.version_info) pubnub = PubNubTornado(pnconf_ssl_copy(), custom_ioloop=self.io_loop) msg = "hey" pub = pubnub.publish().channel(ch).message(msg) envelope = yield pub.future() assert isinstance(envelope, TornadoEnvelope) assert isinstance(envelope.result, PNPublishResult) assert isinstance(envelope.status, PNStatus) assert envelope.result.timetoken > 0 assert len(envelope.status.original_response) > 0 pubnub.stop()
def test_reconnection(self): pnconf = PNConfiguration() pnconf.publish_key = "demo" pnconf.subscribe_key = "demo" pnconf.origin = "localhost:8089" pnconf.subscribe_request_timeout = 10 pnconf.reconnect_policy = PNReconnectionPolicy.LINEAR pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) time_until_open_again = 10 @gen.coroutine def close_soon(): yield gen.sleep(3) pubnub.http.close() pubnub.http = None print(">>> connection is broken") @gen.coroutine def open_again(): yield gen.sleep(time_until_open_again) pubnub.http = tornado.httpclient.AsyncHTTPClient( max_clients=PubNubTornado.MAX_CLIENTS) print(">>> connection is open again") @gen.coroutine def countdown(): yield gen.sleep(2) opened = False count = time_until_open_again while not opened: print(">>> %ds to open again" % count) count -= 1 if count <= 0: break yield gen.sleep(1) my_listener = MySubscribeCallback() pubnub.add_listener(my_listener) pubnub.subscribe().channels('my_channel').execute() yield gen.sleep(1000)
def executionsProcess(self): """ pubnubで価格を取得する場合の処理(基本的に不要.) """ channels = ["lightning_executions_FX_BTC_JPY"] executions = self.executions class BFSubscriberCallback(SubscribeCallback): def message(self, pubnub, message): execution = message.message for i in execution: executions.append(i) config = PNConfiguration() config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' config.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL config.ssl = False config.set_presence_timeout(60) pubnub = PubNubTornado(config) listener = BFSubscriberCallback() pubnub.add_listener(listener) pubnub.subscribe().channels(channels).execute() pubnubThread = threading.Thread(target=pubnub.start) pubnubThread.start()
def setUp(self): super(TestPubNubAsyncHereNow, self).setUp() self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)
def setUp(self): super(TestChannelGroups, self).setUp() self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop)
def test_publish_resultx(self): pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) result = yield pubnub.publish().message('hey').channel('blah').result() assert isinstance(result, PNPublishResult) pubnub.stop()
def test_error_missing_channel(self): self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) self.assert_client_side_error(self.pubnub.publish().channel("").message("hey"), "Channel missing")
def test_error_missing_message(self): self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) self.assert_client_side_error(self.pubnub.publish().channel(ch).message(None), "Message missing")
def setUp(self): AsyncTestCase.setUp(self) config = pnconf_copy() self.pn = PubNubTornado(config, custom_ioloop=self.io_loop)
from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub_tornado import PubNubTornado from pubnub.pnconfiguration import PNReconnectionPolicy import pandas as pd from datetime import datetime, timezone, timedelta #API_KEYとAPI_SECRETを記述 #my_order_size == 一度に買いたい量 my_order_size = 0.001 API_KEY = "Your_API_KEY" API_SECRET = "Your_API_SECRET" config = PNConfiguration() config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' config.reconnect_policy = PNReconnectionPolicy.LINEAR pubnub = PubNubTornado(config) api = pybitflyer.API(api_key=API_KEY, api_secret=API_SECRET) df_all = pd.DataFrame(index=['datetime'], columns=[ 'id', 'side', 'price', 'size', 'exec_date', 'buy_child_order_acceptance_id', 'sell_child_order_acceptance_id' ]) # entry buy or sell position def entry(side, order_size): print('[' + side + ' Entry]') now_tick = api.ticker(product_code="FX_BTC_JPY") #現在の中間価格を代入 if side == 'BUY':
import pybitflyer from pubnub.callbacks import SubscribeCallback from pubnub.enums import PNStatusCategory from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub_tornado import PubNubTornado from pubnub.pnconfiguration import PNReconnectionPolicy from tornado import gen import time import threading import numpy as np c = PNConfiguration() c.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f' c.reconnect_policy = PNReconnectionPolicy.LINEAR pubnub = PubNubTornado(c) api = pybitflyer.API() fx_price = api.ticker(product_code="FX_BTC_JPY")["ltp"] btc_price = api.ticker(product_code="BTC_JPY")["ltp"] disparity_list = [] order = Order() lot = 0.001 maxlot = 0.01 pos = 0 @gen.coroutine def main(channels): class Callback(SubscribeCallback): def message(self, pubnub, message): global disparity_list global fx_price global btc_price
def assert_success_publish_get(self, msg): self.pubnub = PubNubTornado(pnconf, custom_ioloop=self.io_loop) self.assert_success(self.pubnub.publish().channel(ch).message(msg)) self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg))
def assert_success_publish_post_encrypted(self, msg): self.pubnub = PubNubTornado(pnconf_enc, custom_ioloop=self.io_loop) self.assert_success(self.pubnub.publish().channel(ch).message(msg).use_post(True)) self.assert_success_yield(self.pubnub.publish().channel(ch).message(msg).use_post(True))
def setUp(self): super(TestChannelSubscription, self).setUp() self.pubnub = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop) self.pubnub_listener = PubNubTornado(pnconf_sub_copy(), custom_ioloop=self.io_loop)