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)
