def create(**kw):
url = "%s/%s" % (kw.get("broker", broker.OPENSHIFT_BROKER_URL), _path)
cmd = command.command(
{
"alter": {
"class": "optional",
"type": "flag"
},
"debug": {
"class": "optional",
"type": "flag"
},
"ssh": {
"class": "required",
"type": "string"
},
"password": {
"class": "required",
"type": "string"
},
"namespace": {
"class": "required",
"type": "string"
},
"rhlogin": {
"class": "required",
"type": "string"
}
}, kw)
return broker.broker(url, cmd)
def create_broker(root, create=False, verbose=False, debug=False):
"""
Helper function to create broker objects, printing correct error messages if failed
Args:
root: root directory
create: True if missing folders should be created
verbose: verbose progress reporting
debug: even more verbose progress reporting
Returns:
a broker object
"""
# create a broker object
try:
brokerObj = broker(root=root, create=create, verbose=verbose, debug=debug)
except OSError as e:
# if the ddmq.yaml file is missing
if e.errno == errno.EEXIST:
sys.exit("The specified root directory ({}) exists but is not initiated. Please run the same command with the (-f) force flag to try to create and initiate directories as needed.".format(root))
elif e.errno == errno.EACCES:
sys.exit("Unable to write to the specified root directory ({}).".format(root))
except DdmqError as e:
if e.error == 'uninitiated':
sys.exit("The specified root directory ({}) exists but is not initiated. Please run the same command with the (-f) force flag to try to create and initiate directories as needed.".format(root))
elif e.error == 'missing':
sys.exit("The specified root directory ({}) does not exist. Please run the same command with the (-f) force flag to try to create and initiate directories as needed.".format(root))
return brokerObj
def info(**kw):
url = "%s/%s" % (kw.get("broker", broker.OPENSHIFT_BROKER_URL), _path)
cmd = command.command({
"debug": {"class": "optional", "type": "flag"},
"password": {"class": "required", "type": "string"},
"rhlogin": {"class": "required", "type": "string"}}, kw)
return broker.broker(url, cmd)
def newtickets(self, args, flags):
"""Obtain new tickets from broker to create a slice."""
self.sliceconfinit(args[0])
if flags["timeout"]:
agent = self.brokerconf.agents[0] # Not the greatest
host, port = agent["host"], agent["port"]
self.checkreachable(host, port, flags["timeout"])
brok = broker.broker(self.clientconf, self.brokerconf, self.sliceconf)
ticketsdata = brok.newtickets()
self.savetickets(ticketsdata)
self.newslicekeypair()
return 0
def newtickets(self, args, flags):
"""Obtain new tickets from broker to create a slice."""
self.sliceconfinit(args[0])
if flags["timeout"]:
agent = self.brokerconf.agents[0] # Not the greatest
host, port = agent["host"], agent["port"]
self.checkreachable(host, port, flags["timeout"])
brok = broker.broker(self.clientconf, self.brokerconf, self.sliceconf)
ticketsdata = brok.newtickets()
self.savetickets(ticketsdata)
self.newslicekeypair()
return 0
def startup_event():
app.state.redis = broker.broker()
logger.info("redis connected", client=app.state.redis)
# TODO: move all messaging routing to broker module
pubsub = app.state.redis.pubsub()
pubsub.subscribe(**{broker.TURTLE_DEATH: broker.handle_errors})
thread = pubsub.run_in_thread(sleep_time=0.1)
debug_msg = "Listen for errors..."
logger.info(debug_msg,
channel=broker.TURTLE_DEATH,
thread_name=thread.name)
def setup_api(self):
self.tradeObject = []
self.nameExchange = bot.settingbot_df.loc[self.namePort]['nameExchange']
self.apiKey = bot.settingbot_df.loc[self.namePort]['API_Key']
self.secret = bot.settingbot_df.loc[self.namePort]['secret_Key']
self.subaccount = bot.settingbot_df.loc[self.namePort]['subaccount']
self.lineAPI = bot.settingbot_df.loc[self.namePort]['Line_API']
self.mode = bot.settingbot_df.loc[self.namePort]['Mode']
self.mainAsset = bot.settingbot_df.loc[self.namePort]['mainAsset']
self.TradeFuntion = bot.settingbot_df.loc[self.namePort]['TradeFuntion']
self.timeframe = bot.settingbot_df.loc[self.namePort]['timeframe']
self.period = bot.settingbot_df.loc[self.namePort]['period']
self.symbol_A = bot.settingbot_df.loc[self.namePort]['symbol_A']
self.asset_A = bot.settingbot_df.loc[self.namePort]['asset_A']
self.fixvalue_A = bot.settingbot_df.loc[self.namePort]['fixvalue_A']
self.typeTrade_A = bot.settingbot_df.loc[self.namePort]['typeTrade_A']
self.tradeFX_A = bot.settingbot_df.loc[self.namePort]['tradeFX_A']
self.exchangeObject_A = bk.broker(self.apiKey, self.secret, self.subaccount, self.symbol_A, self.nameExchange,self.typeTrade_A)
self.tradeObject_A = [self.symbol_A, self.asset_A, self.fixvalue_A, self.typeTrade_A, self.tradeFX_A,self.exchangeObject_A,self.TradeFuntion,self.timeframe,self.period,'a']
self.tradeObject.append(self.tradeObject_A)
self.symbol_B = bot.settingbot_df.loc[self.namePort]['symbol_B']
self.asset_B = bot.settingbot_df.loc[self.namePort]['asset_B']
self.fixvalue_B = bot.settingbot_df.loc[self.namePort]['fixvalue_B']
self.typeTrade_B = bot.settingbot_df.loc[self.namePort]['typeTrade_B']
self.tradeFX_B = bot.settingbot_df.loc[self.namePort]['tradeFX_B']
self.exchangeObject_B = bk.broker(self.apiKey, self.secret, self.subaccount, self.symbol_B, self.nameExchange,self.typeTrade_B)
self.tradeObject_B = [self.symbol_B, self.asset_B, self.fixvalue_B, self.typeTrade_B, self.tradeFX_B,self.exchangeObject_B,self.TradeFuntion,self.timeframe,self.period,'b']
self.tradeObject.append(self.tradeObject_B)
self.symbol_C = bot.settingbot_df.loc[self.namePort]['symbol_C']
self.asset_C = bot.settingbot_df.loc[self.namePort]['asset_C']
self.fixvalue_C = bot.settingbot_df.loc[self.namePort]['fixvalue_C']
self.typeTrade_C = bot.settingbot_df.loc[self.namePort]['typeTrade_C']
self.tradeFX_C = bot.settingbot_df.loc[self.namePort]['tradeFX_C']
self.exchangeObject_C = bk.broker(self.apiKey, self.secret, self.subaccount, self.symbol_C, self.nameExchange,self.typeTrade_C)
self.tradeObject_C = [self.symbol_C,self.asset_C,self.fixvalue_C,self.typeTrade_C,self.tradeFX_C,self.exchangeObject_C,self.TradeFuntion,self.timeframe,self.period,'c']
self.tradeObject.append(self.tradeObject_C)
def _run(action, **kw):
url = "%s/%s" % (kw.get("broker", broker.OPENSHIFT_BROKER_URL), _path)
kw.update({"action": action})
cmd = command.command({
"cartridge": { "class": "required", "type": "app-cartridge" },
"debug": {"class": "optional", "type": "flag"},
"password": {"class": "required", "type": "string"},
"app_name": {"class": "required", "type": "string"},
"action": {"class": "required", "type": "app-action"},
"rhlogin": {"class": "required", "type": "string"
}}, kw)
return broker.broker(url, cmd)
def __init__(self, suite, db, stop_point, config, pyro, log, run_mode, proc_pool):
self.pyro = pyro
self.run_mode = run_mode
self.log = log
self.qconfig = config.cfg['scheduling']['queues']
self.stop_point = stop_point
self.reconfiguring = False
self.db = db
self.custom_runahead_limit = config.get_custom_runahead_limit()
self.max_future_offset = None
self._prev_runahead_base_point = None
self.max_num_active_cycle_points = (
config.get_max_num_active_cycle_points())
self._prev_runahead_base_point = None
self._prev_runahead_sequence_points = None
self.config = config
self.pool = {}
self.proc_pool = proc_pool
self.runahead_pool = {}
self.myq = {}
self.queues = {}
self.assign_queues()
self.pool_list = []
self.rhpool_list = []
self.pool_changed = []
self.rhpool_changed = []
self.held_future_tasks = []
self.wireless = broadcast(config.get_linearized_ancestors())
self.pyro.connect(self.wireless, 'broadcast_receiver')
self.broker = broker()
self.orphans = []
self.task_name_list = config.get_task_name_list()
def list(url="https://openshift.redhat.com/broker/cartlist"):
return broker.broker(url, { "cart_type": "standalone" })
def test_broker():
broker('AMZN', 'yahoo' '2015-01-01', '2018-01-01')
broker(['INTC', 'NVDA', 'XLNX'], 'yahoo' '2015-01-01', '2018-01-01')
import publisher
import subscriber
import broker
def print_message(message):
print "publisher : %s \ntopic : %s \npayload : %s \n" % (
message.publisher, message.topic, message.payload)
def print_payload(message):
print "payload : %s \n" % (message.payload)
test_brokyer = broker.broker()
message_subscriber = subscriber.subscriber(print_message)
payload_subscriber = subscriber.subscriber(print_payload)
message_subscriber.subscribe(test_brokyer, "test1")
payload_subscriber.subscribe(test_brokyer, "test1")
test_publisher = publisher.publisher()
test_publisher.add_target(test_brokyer, "test1")
test_publisher.add_target(test_brokyer, "test1")
test_publisher.publish("hello world")
test_publisher.publish("ni hao")
def test_correlation_main():
amazon = broker('AMZN', 'yahoo', '2015-01-01', '2018-01-01')
nvidia = broker('NVDA', 'yahoo', '2015-01-01', '2018-01-01')
print(correlation(amazon, 'AMZN', nvidia, 'NVDA'))
correlation(amazon, 'AMZN', nvidia, 'NVDA', 'linear')
correlation(amazon, 'AMZN', nvidia, 'NVDA', 'scatter')
def list(url="https://openshift.redhat.com/broker/cartlist"):
return broker.broker(url, { "cart_type": "embedded" })
import pymysql
## etc
import datetime
import talib
## my custom library
import broker
import filter_stock
import rank_stock
import vis
logic_name = 'Overnight'
start_date = datetime.datetime(2016, 1, 2)
end_date = datetime.datetime(2020, 5, 8)
# start_balance = 10000000 ## 현재 지원되지 않는 기능
broker = broker.broker(logic_name, start_date, end_date, start_balance)
trading_day_list = broker.get_trade_date_list()
if __name__ == '__main__':
## 1. 종목 필터 리스트 추출
filter = filter_stock.filter_stock_list()
filter.run()
for day in trading_day_list:
def main(argv):
coin = ''
exchange = ''
try:
opts, args = getopt.getopt(argv, "hp:")
except getopt.GetoptError:
print 'subibaja.py -p <pair>'
print 'Example: subibaja.py -p USDT_DASH'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'subibaja.py -p <pair>'
sys.exit()
elif opt in ("-p"):
pair = arg
logging.basicConfig(filename='subibaja.log', level=logging.INFO)
# crea el broker que va a operar con el exchange
currito = brk.broker('', '', pair)
# Carga el almacenamiento offline de avisos y usuarios de la app
ddbb = dts.datos('subibaja.db')
#ddbb.firstRun()
#exit()
# coge las cotizaciones del exchange
ahora = int(time.time())
cotizaciones = currito.candlesticks(ahora - 3500000, ahora, 1800)
# pinta candlesticks
grafica = gfx.grafica(pair, cotizaciones)
grafica.addDataToFig(grafica.drawCandleStick())
# pinta selector de rango y volumen
#grafica.drawRangeSelector()
grafica.addDataToFig(grafica.drawVolumeChart())
# pinta media móvil y exponenciales
grafica.addDataToFig(grafica.drawMovingAverage())
grafica.addDataToFig(
grafica.drawExponentialMovingAverage('EMA 1: 30', 30, '#DBA901'))
grafica.addDataToFig(
grafica.drawExponentialMovingAverage('EMA 2: 20', 20, '#A901DB'))
# pinta bolllinger
dataUpper, dataLower = grafica.drawBollinger()
grafica.addDataToFig(dataUpper)
grafica.addDataToFig(dataLower)
# toma de decisiones
oraculo = wtf.aljoritmoh()
compras = oraculo.aboveBollinger(grafica.seriesAvgDate(),
grafica.getLowerBollinger())
ventas = oraculo.underBollinger(grafica.seriesAvgDate(),
grafica.getUpperBollinger())
# pinta los eventos
anotaciones = []
for event in compras:
anotaciones.append(event)
for event in ventas:
anotaciones.append(event)
grafica.drawEvents(anotaciones)
# genera la gráfica
grafica.drawFig()
# comprobando si los últimos avisos son recientes
if not checkEvent(pair, 'buy', compras[-1]):
logging.info("no existe")
date = compras[-1]['x']
value = compras[-1]['y']
ddbb.addEvent(pair, 'buy', date, value)
smsAviso(pair, 'buy', date, value)
if not checkEvent(pair, 'sell', ventas[-1]):
logging.info("no existe")
date = ventas[-1]['x']
value = ventas[-1]['y']
ddbb.addEvent(pair, 'sell', date, value)
smsAviso(pair, 'sell', date, value)
def main(): control = broker(config) control.mediate()
