def analyse(self, orders, start_date, end_date, benchmark_sym=None):
trade_days = Market.get_trade_days(start_date, end_date)
values = []
fee = 0
for timestamp in trade_days:
for order in orders:
t = order.timestamp
if t == timestamp:
f = Trader.make_order(self.portfolio, order)
fee += f
value = self.portfolio.get_value(timestamp)
values.append(value)
benchmark = None
if benchmark_sym:
benchmark = Simulator.get_benchmark(benchmark_sym,
start_date,
end_date)
self.result['days'] = trade_days
self.result['values'] = pd.Series(values, index=trade_days)
self.result['benchmark'] = benchmark
self.result['fee'] = fee
self.result['trades'] = len(orders)
return self.result
def compare():
syms = request.args.get('symbols').split(';')
series = {}
for sym in syms:
stock = Market.get_stock(sym)
close = stock.prices.close
series[sym] = close.to_json(orient="split")
return render_template('compare.html', data=series)
def event_profile(algo, size=30):
buy_window = np.zeros(size)
buy_count = 0
sell_window = np.zeros(size)
sell_count = 0
orders = algo.blotter.orders
for order in orders.values():
stock = Market.get_stock(order.sid, reindex=False)
index = stock.index.searchsorted(order.created)
w = stock['close'].ix[index-size/2:index+size/2] / stock['close'].ix[index]
if order.amount > 0:
buy_window += w
buy_count += 1
else:
sell_window += w
sell_count += 1
buy_window /= buy_count
sell_window /= sell_count
return buy_window, sell_window
def marketsInsert(event, context):
#validation
if 'body' in event:
body=json.loads(event['body'])
if 'name' in body:
name=body['name']
else:
return {'statusCode': 400, 'message': 'Name not provided'}
if 'marketopen' in body:
try:
marketopen=datetime.strptime(body['marketopen'], '%Y-%m-%d')
except ValueError:
return {'statusCode': 400, 'message': 'Invalid market open date format'}
if 'auctionclose' in body:
if len(body['auctionclose']) > 0:
try:
auctionclose=datetime.strptime(body['auctionclose'], '%Y-%m-%d')
except ValueError:
return {'statusCode': 400, 'message': 'Invalid auction close date format'}
else:
auctionclose=None
else:
return {'statusCode': 400, 'message': 'No JSON body provided'}
#save
dbsession=SessionFactory()
try:
newMarket=Market(name=name, marketopen=marketopen, auctionclose = auctionclose)
dbsession.add(newMarket)
dbsession.commit()
dbsession.close()
return {'statusCode': 200}
except:
dbsession.rollback()
dbsession.close()
return {'statusCode': 400, 'message': 'SQL insert error'}
def run_analyse(script, codes, start, end):
open_time = "09:30:00"
close_time = "15:00:00"
start_time = "{0} {1}".format(start, open_time)
end_time = "{0} {1}".format(end, close_time)
sim_params = create_simulation_parameters(
start=pd.to_datetime(start_time).tz_localize("Asia/Shanghai").tz_convert("UTC"),
end=pd.to_datetime(end_time).tz_localize("Asia/Shanghai").tz_convert("UTC"),
data_frequency="daily",
emission_rate="daily",
sids=codes)
with open(script, 'r') as f:
algo_text = f.read()
zp_algo = zipline.TradingAlgorithm(script=algo_text,
namespace={},
capital_base=10e6,
sim_params=sim_params)
stocks = Market.get_stocks(codes, start, end)
d = pd.Panel(stocks)
res = zp_algo.run(d)
results = {}
results['parameters'] = {
'time': datetime.datetime.now(),
'algorithm': script,
}
results['results'] = res
results['report'] = zp_algo.risk_report
results['orders'] = zp_algo.blotter.orders
results['benchmark'] = zp_algo.perf_tracker.all_benchmark_returns
job = get_current_job(connection=Redis())
data.save_result(job.id, results)
return results
def save_commodities(data, session):
authorised = data['header']['softwareName'] in AUTHORISED_SOFTWARES
if not authorised:
return
ts = int(
dateutil.parser.isoparse(data['message']['timestamp']).timestamp())
valid, loop_ts = get_loop_timestamp(ts)
if not valid:
return
system = data['message']['systemName']
station = data['message']['stationName']
market = data['message']['marketId']
for commodity in data['message']['commodities']:
name = commodity['name'].lower()
if name not in commodities_mapping:
continue
commodity_id = commodities_mapping[name]
price = commodity['sellPrice']
mean = commodity['meanPrice']
if price <= mean:
continue
demand = commodity['demand']
entry = session.query(CommodityMaxPrice).filter_by(
commodity_id=commodity_id, timestamp=loop_ts,
market_id=market).first()
if entry is None:
market_entry = session.query(Market).filter_by(id=market).first()
if market_entry is None:
new_market = Market(id=market, system=system, station=station)
session.add(new_market)
new_commodity = CommodityMaxPrice(commodity_id=commodity_id,
sell_price=price,
sell_demand=demand,
timestamp=loop_ts,
updated=ts,
market_id=market)
session.add(new_commodity)
logging.info("New entry: %s", new_commodity)
else:
if entry.market is None:
session.add(Market(id=market, system=system, station=station))
if price > entry.sell_price:
entry.sell_price = price
if price == entry.sell_price and demand > entry.sell_demand:
entry.sell_demand = demand
if price == entry.sell_price or demand == entry.sell_demand:
entry.updated = ts
logging.info("Update entry: %s", entry)
session.merge(entry)
from zipline.utils.factory import create_simulation_parameters
sim_params = create_simulation_parameters(
start = pd.to_datetime("2014-01-01 09:30:00").tz_localize("Asia/Shanghai").tz_convert("UTC"), #Bug in code doesn't set tz if these are not specified (finance/trading.py:SimulationParameters.calculate_first_open[close])
end = pd.to_datetime("2014-12-31 15:00:00").tz_localize("Asia/Shanghai").tz_convert("UTC"),
data_frequency = "daily",
emission_rate = "daily",
sids = ["600000"])
prefix = '000666'
codes = filter(lambda s: s.startswith(prefix), data.get_basics().index)
start = '2014-01-01'
end = '2015-04-30'
benchmark = data.get_hist('sh')
d = Market.get_stocks(codes, start, end)
# d[code].prices.index = d[code].prices.index.to_datetime().tz_localize('UTC')
# d[code].prices['price'] = d[code].prices['close']
d = pd.Panel(d)
with open('/home/leo/Workspace/stock/algorithms/aberration.py', 'r') as f:
algo_text = f.read()
# d = zipline.data.load_bars_from_yahoo(stocks=['AAPL'], start=start, end=end)
algo = zipline.TradingAlgorithm(script=algo_text,
namespace={},
capital_base=100000,
sim_params=sim_params)
# results = algo.run(d, benchmark_return_source=d[code]['close'].pct_change())
results = algo.run(d)
fig = plt.figure()
import zipline
import data
from algorithms import test
import pandas as pd
import matplotlib.pyplot as plt
from analyse import Simulator, BackTester
from strategy import TestStrategy
from model import Market
code = '600000'
start = '2014-01-01'
end = '2014-12-31'
# d = data.get_hist(code, start, end)
d = Market.get_stocks([code])
strategy = TestStrategy()
analyst = BackTester()
sim = Simulator(strategy)
sim.add_analyst('backtest', analyst)
sim.run(d, start, end)
# syms = ["002038.sz"]
# d = zipline.data.load_bars_from_yahoo(stocks=syms, start='2014-01-01', end='2014-12-31',)
# algo = zipline.TradingAlgorithm(initialize=test.initialize,
# handle_data=test.handle_data,
# namespace={},
# capital_base=10e6)
# results = algo.run(d)
def _stock(sym):
stock = Market.get_stock(sym)
return stock.prices.to_json(orient="split")
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////home/raviteja/betbright/betBright.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
# See important note below
from model import Market
from model import Selection
from model import Event
from model import Message
from model import Sport
#Simple data insertions for available tables
s1 = Selection(name="Poland",odds=3.01)
s2 = Selection(name="Irland",odds=7.01);
m1 = Market(name="Winner",selections=[s1,s2])
ev1 = Event("Poland vs Irland","http://example.com/api/match/2",2,1)
db.session.add(m1)
db.session.add(s1)
db.session.add(s2)
db.session.add(ev1)
db.session.commit()
def get_benchmark(sym, start_date, end_date):
bench = Market.get_stock(sym,
start_date,
end_date)
benchmark = bench.prices['close']
return benchmark
