def OnWorking(self): # 供具体策略继承调用，在 运行 前执行一些操作
if self.subscribe == False:
self.center.RegQuoteSub(self.strategy, self.OnQuoteFuture, "future_np")
self.subscribe = True
self.trader = trader.Trader().GetTrader("sqqh")
if self.trader == None:
self.logger.SendMessage("E", 4, self.log_cate, "获取标识为 sqqh 的交易服务失败！", "M")
def test_connect(self):
with mock.patch('utility.ConfigManager') as MockConfig:
MockConfig.return_value.get_config.return_value = '{ "DEFAULT" : {"VALUE_ONE" : "foo", "SECOND_VALUE" : "bar" }}'
sut = trader.Trader(MockConfig)
sut.g
MockConfig.asset_called_once
print(f'result {sut.connect()}')
def SystemStart(self):
self.log_text = "开始系统初始化 ..."
self.logger.SendMessage("I", 1, self.log_cate, self.log_text, "S")
self.basicx = basicx.BasicX()
if self.config.cfg_main.data_db_need == 0:
self.basicx.InitBasicData(folder = self.config.cfg_main.data_folder) # 不使用数据库
if self.config.cfg_main.data_db_need == 1:
self.basicx.InitBasicData(host = self.config.cfg_main.data_db_host, port = self.config.cfg_main.data_db_port,
user = self.config.cfg_main.data_db_user, passwd = self.config.cfg_main.data_db_pass,
folder = self.config.cfg_main.data_folder)
self.trader = trader.Trader()
self.trader.start()
self.strate = strate.Strate()
self.strate.LoadStrategy()
self.main_tab_panel_1.OnReloadStrategy()
self.strate.start()
self.log_text = "系统初始化完成。"
self.logger.SendMessage("I", 1, self.log_cate, self.log_text, "S")
self.CreateTrayIcon()
self.log_text = "加载系统托盘图标完成。"
self.logger.SendMessage("I", 1, self.log_cate, self.log_text, "S")
self.OnShowTrayIconMsg(define.APP_TITLE_EN + " " + define.APP_VERSION)
def OnWorking(self): # 供具体策略继承调用，在 运行 前执行一些操作
if self.subscribe == False:
self.center.RegQuoteSub(self.strategy, self.OnQuoteStock,
"stock_ltp") # 目前只订阅个股
self.subscribe = True
self.trader = trader.Trader().GetTrader("hbzq")
if self.trader == None:
self.logger.SendMessage("E", 4, self.log_cate,
"获取标识为 hbzq 的交易服务失败！", "M")
def __init__(self):
self.conn = poloniex.Poloniex(po_api.api_key, po_api.secret)
self.active_trader = trader.Trader()
self.actions = [
'BUY_USDC_BTC',
'BUY_BTC_ETH',
'BUY_BTC_XMR',
'BUY_BTC_XRP',
'BUY_BTC_DOGE',
'SELL_USDC_BTC',
'SELL_BTC_ETH',
'SELL_BTC_XMR',
'SELL_BTC_XRP',
'SELL_BTC_DOGE',
]
self.state = []
def construct_trader(strategy_file, config):
'''
Creates a trader dict.
Arguments:
strategy_file (str): The name of the strategy file.
config (module): The config module.
Returns:
{
'name': strategy name,
'trader': Trader,
'thread': Thread
}
'''
# Load the strategy module. We know that it will be a filename
# ending with ".py" so we can split it at this sequence and keep
# the first part.
module_name = strategy_file.name.split('.py')[0]
strategy_module = sys.modules.get(module_name)
if strategy_module:
importlib.reload(strategy_module)
else:
strategy_module = importlib.import_module(module_name)
# Create a Trader.
_trader = tr.Trader(api_key=config.api_key,
api_secret=config.api_secret,
config=config,
strategy=strategy_module)
_trader.daemon = True
# Create thread to run the Trader on.
# _thread = Thread(target=_trader.run_forever, daemon=True)
# Rename the thread so we can use it's name for logging.
# _thread.name = module_name
_trader.name = module_name
#return {'name': module_name, 'trader': _trader, 'thread': _thread}
#return {'name': module_name, 'trader': _trader}
return _trader
def __init__(self, name):
self.name = name
self.trader = trader.Trader()
self.speaker = speaker.Speaker()
self.trader.binance_public = keys.binance_public
self.trader.binance_private = keys.binance_private
self.speaker.tele_token = keys.telegram_token
self.speaker.tele_chatid = keys.telegram_chatid
self.state = "shut down" #Other states : "sleeping" (only listening) and "awake" (listening, trading and sending updates)
#Set-up loggers
self.error_log = setup_logger("Error logger", PATH + '/error_log.txt',
logging.ERROR)
self.trade_log = setup_logger("Trade logger", PATH + '/trade_log.txt',
logging.INFO)
self.listening_thread = None
self.sending_thread = None
self.trading_thread = None
self.listening = False
self.trading = False
self.sending = False
self.verbose = True
self.show_too_low = False
self.commands = {
'Go sleep': self.go_sleep,
'Wake up!': self.wake_up,
'Shutdown': self.shut_down,
'Talk to me': self.set_verbose,
'Be quiet': self.set_verbose,
'Last trade': self.last_trade,
'Show too low': self.set_show_too_low,
'You alright?': self.get_state,
'Get <attribute>': None
}
def __init__(self, flag, show, tips):
self.flag = flag
self.show = show
self.tips = tips
self.log_text = ""
self.log_cate = "TradeBarItem"
self.logger = logger.Logger()
self.trader = trader.Trader()
self.check_box = QCheckBox()
self.check_box.setCheckable(True)
self.check_box.setChecked(False)
self.check_box.setFont(QFont("SimSun", 8, QFont.Bold))
self.check_box.setText(show)
self.check_box.setToolTip(tips)
self.state_label = QLabel()
self.state_label.setFont(QFont("SimSun", 8, QFont.Bold))
self.state_label.setMinimumWidth(40)
self.state_label.setMinimumHeight(17)
self.state_label.setText("OFF")
self.state_label.setStyleSheet("color:rgb(96,96,96);")
self.state_label.setToolTip(tips)
self.check_box.clicked.connect(self.HandleConnectEvent)
def start_trading(self):
self.evaluate_agents()
t = trader.Trader(self.init_equity, self.stock_list, self.agent_list, self.alpaca)
threading.Thread(target=t.start_live_trading).start()
tickerSymbol = 'AAPL'
tickerData = yf.Ticker(tickerSymbol)
tickerDf = tickerData.history(period='1d', start='2020-1-1', end='2020-6-1')
tickerDf.reset_index(inplace=True)
df_daily = sdf.retype(tickerDf)
df_daily.get('macd')
stock_add = 1
indicator = 'macd'
df_daily.reset_index(inplace=True)
profit, net = T.Trader(df_daily, indicator, stock_add).trading_decision()
profit_regular = (stock_add * df_daily['close'].iloc[-1]) - (
stock_add * df_daily['close'].iloc[0])
print('Profit MACD: ' + str(profit))
print('Profit keep and sell: ' + str(profit_regular))
fig = viz.viz_candlestick(df_daily)
fig.update_layout(
title={
'text': "Candlestick Chart",
'y': 0.9,
'x': 0.5,
'xanchor': 'center',
'yanchor': 'top'
})
import importlib
import logging
import backend, rules, data, trader, scheduler, rules
logging.basicConfig(
level=logging.INFO,
format='%(levelname)s %(module)s %(funcName)s() %(message)s',
filename="happy_asset.log",
filemode="w")
logging.info("Logging initialized")
my_backend_module = importlib.import_module("replay")
my_backend = my_backend_module.Backend()
rules = [
getattr(rules, "rule3percent_sell"),
getattr(rules, "uptrend_buy"),
getattr(rules, "rule3percent_buy")
]
# getattr(rules, "uptrend_sell")]
my_trader = trader.Trader(my_backend, 300, .1)
my_scheduler = scheduler.Scheduler(my_trader, rules, data.Data(), 0)
my_scheduler()
def setUp(self) -> None:
self.sample_trader = trader.Trader(balance, start_date, days_run)
import trader as t
trader = t.Trader('FEB11346579 ', 'GULBEX')
trader.block('UGES', 20000)
print("Waiting for end of cycle")
time.sleep(10)
trader.forceShutDown()
print("Trader has shut down")
def startTrading(trader):
trader.startTrading()
if __name__ == "__main__":
trader_data_file = open("txt_files/trader_data.txt", "r")
trader_data = json.loads(trader_data_file.read())
trader = trdr.Trader(trader_data["money"], trader_data["stocks"])
traderThread = threading.Thread(target=startTrading,
args=(trader, ),
daemon=True)
traderThread.start()
while True:
print("Write 'status' to see the trader's current status")
print("Write 'stop' to end trading asap")
command = input(">>> ")
command = command.lower()
if command == "status":
print(trader.getStateString())
if command == "stop":
forceTraderShutDown(trader)
import trader
t = trader.Trader()
t.print_bid_ask_summery('BTCUSD')
str(money))
record_content = dt_string + "\n" + record + "\n" + trader.getStateString(
) + "\n\n"
print(record_content)
record_file.write(record_content)
record_file.close()
def handleBuy(self, trader, stock_symbol, money_to_spend):
unit_price = self.getStockPrice(stock_symbol)
quantity_bought = money_to_spend / unit_price
trader.addStocks(stock_symbol, quantity_bought)
trader.updateMoney(-money_to_spend)
#self.recordTransaction(ACTION_CODE_BUY, trader, stock_symbol, quantity_bought, money_to_spend)
def handleSell(self, trader, stock_symbol):
unit_price = self.getStockPrice(stock_symbol)
quantity_to_sell = trader.getOwnedStockQuantity(stock_symbol)
money_gained = unit_price * quantity_to_sell
trader.removeStock(stock_symbol)
trader.updateMoney(money_gained)
#self.recordTransaction(ACTION_CODE_SELL, trader, stock_symbol, quantity_to_sell, money_gained)
if __name__ == '__main__':
broker = Broker()
#print(broker.getStockPrice('ETH'))
trader = trader.Trader(8000, {})
broker.handleBuy(trader, "BTC", 8000)
broker.handleSell(trader, "BTC")
import trader
import ratingDAO
rating = ratingDAO.RatingDAO()
"""
simulator1: 1 share of first 10 stocks
"""
simulator1 = trader.Trader()
for stock in rating.select(10):
print stock[0]
simulator1.buy(stock[0], "simulator1", 1)
"""
simulator2: $100 each of top 10 stocks
"""
simulator2 = trader.Trader()
for stock in rating.select(10):
print simulator2.getPrice(stock[0])
simulator2.buy(stock[0], "simulator2",
int(100 / float(simulator2.getPrice(stock[0]))))
"""
simulator3: 1 share of first 25 stocks
"""
simulator3 = trader.Trader()
for stock in rating.select(25):
simulator3.buy(stock[0], "simulator3", 1)
"""
simulator 4: $100 each of top 25 stocks
"""
simulator4 = trader.Trader()
for stock in rating.select(25):
BTC_QUANT = .05
USD_DIFF = .005
SPREAD_DIFF = .0015
myTrader = None
def newPrice(bid, ask):
buyUsd = bid[0] + USD_DIFF
sellUsd = ask[0] - USD_DIFF
profit = (sellUsd - buyUsd) - FEE * (buyUsd + sellUsd)
print "you can make $", profit, "on the current spread"
print 'bid is: ', bid
print 'ask is: ', ask
info = myTrader.getInfo()
if profit > SPREAD_DIFF * buyUsd and info['funds'][
'btc'] > BTC_QUANT and info['funds']['usd'] > buyUsd * BTC_QUANT:
myTrader.trade(True, buyUsd, BTC_QUANT)
myTrader.trade(False, sellUsd, BTC_QUANT)
print "made trades"
if __name__ == '__main__':
try:
myTrader = trader.Trader()
depths = priceDepths.Depths(newPrice)
while True:
time.sleep(10)
except (KeyboardInterrupt, SystemExit):
depths.close()
sys.exit()
gdax = exchanges.GDAX()
kraken = exchanges.KRAKEN()
poloniex = exchanges.POLONIEX()
exchanges = [gdax, kraken, poloniex]
try:
if sys.argv[1] == "-v":
# make verbose
for exchange in exchanges:
exchange.verbose = True
elif sys.argv[1] == "-q":
# make quiet
for exchange in exchanges:
exchange.verbose = False
except:
pass
exchange_tickers = []
for exchange in exchanges:
exchange_tickers.append(exchange.ticker())
trader = t.Trader()
trader.verbose = True
## ~~ ## ~~ ##
print "\n"
trader.compare(exchange_tickers)
print "\n"
