def subscribe_ticker(self, ticker):
"""
Subscribes the price handler to a new ticker symbol.
"""
if ticker not in self.tickers:
try:
self._open_ticker_price_csv(ticker)
dft = self.tickers_data[ticker]
row0 = dft.iloc[0]
close = PriceParser.parse(row0["Close"])
adj_close = PriceParser.parse(row0["Adj Close"])
ticker_prices = {
"close": close,
"adj_close": adj_close,
"timestamp": dft.index[0]
}
self.tickers[ticker] = ticker_prices
except OSError:
print("Could not subscribe ticker %s "
"as no data CSV found for pricing." % ticker)
else:
print("Could not subscribe ticker %s "
"as is already subscribed." % ticker)
def _create_event(self, index, ticker, row):
"""
Obtain all elements of the bar a row of dataframe
and return a TickEvent
"""
bid = PriceParser.parse(row["Bid"])
ask = PriceParser.parse(row["Ask"])
tev = TickEvent(ticker, index, bid, ask)
return tev
def update(self, timestamp, portfolio_handler):
"""
Update equity curve and benchmark equity curve that must be tracked
over time.
"""
self.equity[timestamp] = PriceParser.display(
self.portfolio_handler.portfolio.equity)
if self.benchmark is not None:
self.equity_benchmark[timestamp] = PriceParser.display(
self.price_handler.get_last_close(self.benchmark))
def _create_event(self, index, ticker, row):
"""
Obtain all elements of the bar a row of dataframe
and return a TickEvent
"""
try:
bid = PriceParser.parse(row["Bid"])
ask = PriceParser.parse(row["Ask"])
tev = TickEvent(ticker, index, bid, ask)
return tev
except ValueError:
raise EmptyTickEvent("row %s %s %s can't be convert to TickEvent" %
(index, ticker, row))
def _create_event(self, index, period, ticker, row):
"""
Obtain all elements of the bar from a row of dataframe
and return a BarEvent
"""
open_price = PriceParser.parse(row["Open"])
high_price = PriceParser.parse(row["High"])
low_price = PriceParser.parse(row["Low"])
close_price = PriceParser.parse(row["Close"])
adj_close_price = PriceParser.parse(row["Adj Close"])
volume = int(row["Volume"])
bev = BarEvent(ticker, index, period, open_price, high_price,
low_price, close_price, volume, adj_close_price)
return bev
def calculate_ib_commission(self, quantity, fill_price):
"""
Calculate the Interactive Brokers commission for
a transaction. This is based on the US Fixed pricing,
the details of which can be found here:
https://www.interactivebrokers.co.uk/en/index.php?f=1590&p=stocks1
"""
commission = min(0.5 * fill_price * quantity,
max(1.0, 0.005 * quantity))
return PriceParser.parse(commission)
def _create_event(self, index, period, ticker, row):
"""
Obtain all elements of the bar from a row of dataframe
and return a BarEvent
"""
try:
open_price = PriceParser.parse(row["Open"])
high_price = PriceParser.parse(row["High"])
low_price = PriceParser.parse(row["Low"])
close_price = PriceParser.parse(row["Close"])
adj_close_price = PriceParser.parse(row["Adj Close"])
volume = int(row["Volume"])
# Create the tick event for the queue
bev = BarEvent(ticker, index, period, open_price, high_price,
low_price, close_price, volume, adj_close_price)
return bev
except ValueError:
raise EmptyBarEvent(
"row %s %s %s %s can't be convert to BarEvent" %
(index, period, ticker, row))
def calculate_signals(self, event, agent=None):
if event.type in [EventType.TICK, EventType.BAR]:
# Format the event for human display
if event.type == EventType.BAR:
event.open_price = PriceParser.display(event.open_price)
event.high_price = PriceParser.display(event.high_price)
event.low_price = PriceParser.display(event.low_price)
event.close_price = PriceParser.display(event.close_price)
event.adj_close_price = PriceParser.display(
event.adj_close_price)
else: # event.type == EventType.TICK
event.bid = PriceParser.display(event.bid)
event.ask = PriceParser.display(event.ask)
if self.i % self.n == 0 and self.i != 0:
print(s_speed(event, self.i, self.t0))
print("")
if self.i % self.n in range(self.n_window):
print("%d %s" % (self.i, event))
self.i += 1
def x(p):
return PriceParser.display(p)
def __init__(self, env, context, config, indicators, strategiesDict, instanceDict) :
#testing, filename,
#QQQ benchmark, ticker_weights, title_str, equity):
super(AgentFactory, self).__init__(env)
self.context = context
ticketWeights = instanceDict["tickerWeights"]
start_date = instanceDict["startDate"]
end_date = instanceDict["endDate"]
strategy = instanceDict["strategy"]
benchmark = instanceDict["benchmark"]
equity = instanceDict["equity"]
start_date = parser.parse(start_date)
end_date = parser.parse(end_date)
print strategiesDict, start_date, end_date
positionSizer = strategiesDict['positionSizer']
riskManager = strategiesDict['riskManager']
portfolioHandler = strategiesDict['portfolioHandler']
complianceHandler = strategiesDict['complianceHandler']
executionHandler = strategiesDict['executionHandler']
tearsheetStatistics = strategiesDict['tearsheetStatistics']
displayStrategy = strategiesDict['displayStrategy']
learningHandler = strategiesDict['learningHandler']
strategyHandler = strategiesDict['strategyHandler']
title = strategiesDict['title']
tmpArray = learningHandler.split(".")
learningClass = getattr(importlib.import_module("action." + tmpArray[0]), "Action")
self.learningHandler = learningClass(self.context,instanceDict)
self.totalActions = 0.0
self.totalRewards = 0.0
#self.config = settings.from_file(config, testing)
self.tickers = [t for t in ticketWeights.keys()]
# Set up variables needed for backtest
self.events_queue = queue.Queue()
self.csv_dir = config.CSV_DATA_DIR
self.initial_equity = PriceParser.parse(equity)
# Use Yahoo Daily Price Handler
self.price_handler = YahooDailyCsvBarPriceHandler(
self.csv_dir, self.events_queue, self.tickers,
start_date=start_date, end_date=end_date
)
tmpArray=strategyHandler.split(".")
# Use the monthly liquidate and rebalance strategy
strategyClass = getattr(importlib.import_module("smarttrader.strategy."+tmpArray[0]), "Strategy")
displayClass = getattr(importlib.import_module("smarttrader.strategy.display"), displayStrategy)
self.strategy = strategyClass(self.tickers, self.events_queue)
strategy = Strategies(self.strategy, displayClass())
# Use the liquidate and rebalance position sizer
# with prespecified ticker weights
tmpArray = positionSizer.split(".")
rebalancingClass = getattr(importlib.import_module("smarttrader.position_sizer."+tmpArray[0]), tmpArray[1])
self.position_sizer = rebalancingClass(ticketWeights)
# Use an example Risk Manager
tmpArray = riskManager.split(".")
riskManagerClass = getattr(importlib.import_module("smarttrader.risk_manager."+tmpArray[0]), tmpArray[1])
self.risk_manager = riskManagerClass()
# Use the default Portfolio Handler
tmpArray = portfolioHandler.split(".")
portHandlerClass = getattr(importlib.import_module("smarttrader.portfolio."+tmpArray[0]), tmpArray[1])
self.portfolio_handler = portHandlerClass(self.initial_equity, self.events_queue, self.price_handler,
self.position_sizer, self.risk_manager)
# Use the ExampleCompliance component
tmpArray = complianceHandler.split(".")
complianceClass = getattr(importlib.import_module("smarttrader.compliance."+tmpArray[0]), tmpArray[1])
self.compliance = complianceClass(config)
# Use a Indicator component
self.indicator_list = list()
self.indicator_dict = dict()
for indicator, value in indicators.iteritems():
print indicator, value
tmpArray = value['indicator'].split(".")
indicatorClass = getattr(importlib.import_module("smarttrader.indicators."+tmpArray[0]), tmpArray[1])
instance = indicatorClass(self.tickers, self.events_queue,value)
self.indicator_list.append(instance)
self.indicator_dict[value['indicator']] = instance
# Use a simulated IB Execution Handler
tmpArray = executionHandler.split(".")
execHandlerClass = getattr(importlib.import_module("smarttrader.execution_handler." + tmpArray[0]), tmpArray[1])
self.execution_handler = execHandlerClass(self.events_queue, self.price_handler, self.compliance)
# Use the default Statistics
self.title = [title]
tmpArray = tearsheetStatistics.split(".")
statClass = getattr(importlib.import_module("smarttrader.statistics."+tmpArray[0]), tmpArray[1])
self.statistics = statClass(config, self.portfolio_handler, self.title, benchmark)
def _create_event(self, data):
ticker = data["name"]
index = pd.to_datetime(data["values"]["UPDATE_TIME"])
bid = PriceParser.parse(data["values"]["BID"])
ask = PriceParser.parse(data["values"]["OFFER"])
return TickEvent(ticker, index, bid, ask)
def __init__(self, config, strategyDict, instanceDict):
print instanceDict
ticketWeights = instanceDict["tickerWeights"]
start_date = instanceDict["startDate"]
end_date = instanceDict["endDate"]
strategy = instanceDict["strategy"]
benchmark = instanceDict["benchmark"]
equity = instanceDict["equity"]
start_date = datetime.datetime(2007, 12, 4)
end_date = datetime.datetime(2016, 10, 12)
self.color = 'red'
self.qTable = LearningAgentQTable(alpha=0.5, gamma=0.3, epsilon=0.5)
self.totalActions = 0.0
self.totalRewards = 0.0
# self.config = settings.from_file(config, testing)
self.tickers = [t for t in ticketWeights.keys()]
# Set up variables needed for backtest
self.events_queue = queue.Queue()
self.csv_dir = config.CSV_DATA_DIR
self.initial_equity = PriceParser.parse(500000.00)
# Use Yahoo Daily Price Handler
self.price_handler = YahooDailyCsvBarPriceHandler(
self.csv_dir,
self.events_queue,
self.tickers,
start_date=start_date,
end_date=end_date)
# Use the monthly liquidate and rebalance strategy
self.strategy = BuyAndHoldStrategy(self.tickers, self.events_queue)
strategy = Strategies(self.strategy, DisplayStrategy())
#strategyClass = getattr(importlib.import_module("qstrader.strategy.buy_and_hold"), "BuyAndHoldStrategy")
#displayClass = getattr(importlib.import_module("qstrader.strategy.display"), "DisplayStrategy")
#strategy = strategyClass(self.strategy, displayClass())
# Use the liquidate and rebalance position sizer
# with prespecified ticker weights
self.position_sizer = LiquidateRebalancePositionSizer(ticketWeights)
#rebalancingClass = getattr(importlib.import_module("qstrader.position_sizer.rebalance"), "LiquidateRebalancePositionSizer")
#strategy = rebalancingClass(ticketWeights)
# Use an example Risk Manager
self.risk_manager = ExampleRiskManager()
#riskManagerClass = getattr(importlib.import_module("qstrader.risk_manager.example"), "ExampleRiskManager")
#self.risk_manager = riskManagerClass()
# Use the default Portfolio Handler
self.portfolio_handler = PortfolioHandler(self.initial_equity,
self.events_queue,
self.price_handler,
self.position_sizer,
self.risk_manager)
#portHandlerClass = getattr(importlib.import_module("qstrader.portfolio.portfolio_handler"), "PortfolioHandler")
#strategy = portHandlerClass(self.initial_equity, self.events_queue, self.price_handler,
# self.position_sizer, self.risk_manager)
# Use the ExampleCompliance component
self.compliance = ExampleCompliance(config)
#complianceClass = getattr(importlib.import_module("qstrader.compliance.example"), "ExampleCompliance")
#self.compliance = complianceClass(config)
# Use a simulated IB Execution Handler
self.execution_handler = IBSimulatedExecutionHandler(
self.events_queue, self.price_handler, self.compliance)
#execHandlerClass = getattr(importlib.import_module("qstrader.execution_handler.ib_simulated"), "IBSimulatedExecutionHandler")
#self.execution_handler = execHandlerClass(self.events_queue, self.price_handler, self.compliance)
# Use the default Statistics
self.title = [strategyDict.get('title')]
self.statistics = TearsheetStatistics(config, self.portfolio_handler,
self.title, benchmark)