def profit_percent_chart(): portfolio = Portfolio(1) start_date = None end_date = datetime.now() time_range = TimeRange(start_date, end_date) cur = request.args.get('cur', Portfolio.RUB) data = portfolio.get_value_history(time_range, currency=cur) cbr_data = portfolio.get_cbr_history(time_range, currency=cur) cash_data = portfolio.get_cash_history(time_range, currency=cur) samples = [100 * (data - cash_data) / cash_data, 100 * (cbr_data - cash_data) / cash_data] data = { 'data': [], 'layout': RANGE_LAYOUT } for sample in samples: data['data'].append({ 'x': list(sample.keys()), 'y': list(sample.values()), 'name': sample.title, }) data = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder) return templating.render_template('chart.html', data=data)
def create(self): """Create a new portfolio.""" filename = input("File name to create: ") path = Path(filename) if not path.exists(): self.portfolio = Portfolio(path=path) self.add()
def portfolio_chart(): portfolio = Portfolio(portfolio_id=1) state_asset, state_cur = portfolio.get_state(total=False) values = [] labels = [] for item in state_asset: ticker, name, quantity, sec_cur, position_orig, position = item values.append(position) labels.append(name) data = { 'data': [ { 'values': values, 'labels': labels, 'type': 'pie' } ], 'layout': { 'autosize': False, 'width': 1900, 'height': 900, } } data = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder) return templating.render_template('chart.html', data=data)
def test_it_returns_the_debt_to_equity_ratio_for_a_historical_time(self): asset = AccountBuilder().set_name("name") \ .set_institution("institution") \ .set_owner("owner") \ .set_investment("investment") \ .set_asset_class(AssetClass.NONE) \ .set_account_type(AccountType.ASSET) \ .build() liability = AccountBuilder().set_name("name") \ .set_institution("institution") \ .set_owner("owner") \ .set_investment("investment") \ .set_asset_class(AssetClass.NONE) \ .set_account_type(AccountType.LIABILITY) \ .build() timestamp = EpochDateConverter().date_to_epoch() early_timestamp = timestamp - 200000 query_time = timestamp - 100000 asset.import_snapshot(timestamp, 112233) liability.import_snapshot(early_timestamp, 223344) portfolio = Portfolio() portfolio.import_account(asset) portfolio.import_account(liability) self.assertEqual( PortfolioAnalyzer(portfolio).debt_to_equity( EpochDateConverter().epoch_to_date(query_time)), 1.0)
def profit_chart(): start_date = None end_date = datetime.now() time_range = TimeRange(start_date, end_date) cur = request.args.get('cur', Portfolio.RUB) broker = request.args.get('broker') portfolio = Portfolio(1, broker_id=int(broker) if broker else None) data = portfolio.get_value_history(time_range, currency=cur) cbr_data = portfolio.get_cbr_history(time_range, currency=cur) cash_data = portfolio.get_cash_history(time_range, currency=cur) dividend_data = portfolio.get_dividend_history(time_range, currency=cur) commission_data = portfolio.get_commission_history(time_range, currency=cur) samples = [data - cash_data, cbr_data - cash_data, dividend_data, commission_data] data = { 'data': [], 'layout': RANGE_LAYOUT } for sample in samples: data['data'].append({ 'x': list(sample.keys()), 'y': list(sample.values()), 'name': sample.title, }) data = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder) return templating.render_template('chart.html', data=data)
def __init__(self, portfolio=Portfolio()): self.portfolio = portfolio self.headers = [ "Last Updated", "Institution", "Account", "Investment", "Owner", "Value" ] self.spacers = ["---", "---", "---", "---", "---", "---"]
def main(portfolioJsonFilePath, updateCacheAfterMinutes): currentTime = datetime.now() currentEpoch = int(currentTime.timestamp()) lastEpoch = utils.getLastUpdateEpochTime() currentTimeEST = datetime.now(pytz.timezone('US/Eastern')) currentTime = datetime.now() print("Local Time:\t", currentTime.strftime("%Y-%m-%d %I:%M %p, %A")) print("EST Time:\t", currentTimeEST.strftime("%Y-%m-%d %I:%M %p, %A")) print("***********************************") if isCacheStale(currentEpoch, lastEpoch, updateCacheAfterMinutes * MINUTES_TO_SECONDS): print("===Updating Data===") utils.setLastUpdateEpochTime(currentEpoch) TickerCache.clearCache() else: print("===Using Cached Data===") portfoliosJson = json.loads(utils.getFileData(portfolioJsonFilePath)) portfolios = list() for portfolioJson in portfoliosJson["portfolios"]: portfolio = Portfolio() portfolio.parse(portfolioJson) portfolios.append(portfolio) portfolioPrependStr = "" for portfolio in portfolios: Portfolio.printHeader(portfolioPrependStr) portfolio.print(portfolioPrependStr) TickerCache.saveCache()
def __init__(self, **kwargs): ''' kwargs: { execution: {single_stock, multi_stocks}, portfolio: {sharpe, dsharpe, ... ...} valuer: {MarketValuer, SharpeValuer, ... ... } } ''' ### common variables self.__sym = kwargs['sym'] self.__start = kwargs['start'] self.__end = kwargs['end'] ### market data providers self.__provider = MarketDataProvider('quandl', self.__sym, self.__start, self.__end) self.__OHLCV = self.__provider.getMarketData('OHLCV') self.__sma10 = self.__provider.getMarketData('close_sma', period=1) if (kwargs['execution'] == 'single_stock'): self.__executionservice = SingleStockExecutionSimulator( self.__sym, self.__start, self.__end, self.__OHLCV) self.__initial_value = 100000 self.__current_value = self.__initial_value if (kwargs['portfolio'] == 'basic'): self.__portfolio = Portfolio(self.__current_value) if (kwargs['valuer'] == 'market'): self.__portfolio_valuer = MarketValuer() self.__oms = OMS(self.__executionservice, self.__portfolio, self.__portfolio_valuer)
def main() -> None: """Entry point for the portfolio app.""" logger.debug('Running "%s" in "%s"', " ".join(sys.argv), Path(".").resolve()) with Portfolio() as portfolio: args = make_parser().parse_args() logger.debug("Arguments parsed as %s", args) if hasattr(args, "func"): with PortfolioConfig() as config: args.func(args, portfolio, config)
def setUp(self): home_currency = "GBP" leverage = 20 equity = Decimal("100000.00") risk_per_trade = Decimal("0.02") ticker = TickerMock() events = {} self.port = Portfolio( ticker, events, home_currency=home_currency, leverage=leverage, equity=equity, risk_per_trade=risk_per_trade )
def example_rolling(): start_date = Date(2019, 1, 3) oc = generate_cube(start_date, 0.88, 0.92) udl = oc.iloc[0].iloc[1].iloc[0].udl udls = udl.series dates = udls.index[udls.index.get_loc(Date(2019, 1, 3))::] cash_asset = OneUsd() rule = RollingPut(udl, oc) portfolio = Portfolio(rule, cash_asset, 100.0, start_date) portfolio.compute(dates) portfolio.report().to_clipboard() print(portfolio.report().head())
def gle_cppi(): risky_asset = EquityYFinance("GLE.PA") maturity = Date(2025, 1, 5) zero_coupon = ZeroCouponFake(0.01, maturity, "long_rate_1") rule = CPPI_simple(risky_asset, zero_coupon, maturity, 25, 80.0) cash_asset = ZeroCouponFake(0.001, Date(2100, 1, 1), "cash_10_bp") start_date = Date(2021, 1, 4) portfolio = Portfolio(rule, cash_asset, 100.0, start_date) dates = risky_asset.h.index[risky_asset.h.index >= start_date] portfolio.compute(dates) portfolio.report().to_clipboard() print(portfolio.report().head())
def test_it_returns_the_debt_to_equity_ratio_for_a_portfolio_with_only_liabilities( self): account = AccountBuilder().set_name("name") \ .set_institution("institution") \ .set_owner("owner") \ .set_investment("investment") \ .set_asset_class(AssetClass.NONE) \ .set_account_type(AccountType.LIABILITY) \ .build() account.import_snapshot(EpochDateConverter().date_to_epoch(), 1234) portfolio = Portfolio() portfolio.import_account(account) self.assertEqual(PortfolioAnalyzer(portfolio).debt_to_equity(), 1.0)
def setUp(self): self.portfolio = Portfolio() self.asset_data_1 = {"timestamp": "2017-06-01", "name": "Proctor and Gamble", "investment": "PG", "value": 1000, "asset_class": "Equities", "owner": "Bob", "institution": "Bank 1", "account_type": "ASSET", "update_frequency": 2, "term": "none"} self.asset_data_2 = {"timestamp": "2017-07-01", "name": "Vanguard Bond Fund", "investment": "VTIBX", "value": 2000, "asset_class": "Fixed Income", "owner": "Sam", "institution": "Bank 2", "account_type": "ASSET", "update_frequency": 9, "term": "none"} self.liability_data_1 = {"timestamp": "2017-06-05", "name": "Visa Card", "value": 1000, "investment": "CASHX", "institution": "Bank 1", "account_type": "LIABILITY", "asset_class": "None", "owner": "Craig", "update_frequency": 15, "term": "none"} self.liability_data_2 = {"timestamp": "2017-07-05", "name": "Personal Loan", "value": 1500, "investment": "CASHX", "institution": "Bank 2", "account_type": "LIABILITY", "asset_class": "None", "owner": "Eusavio", "term": "none"}
def setUp(self): self.asset = AccountBuilder().set_name("name") \ .set_owner("owner") \ .set_investment("investment") \ .set_institution("institution") \ .set_update_frequency(3) \ .build() self.liability = AccountBuilder().set_name("name") \ .set_owner("owner") \ .set_investment("investment") \ .set_institution("institution") \ .set_liability() \ .build() self.portfolio = Portfolio()
def recommendation(): # number of recommended items numberOfItems = 20 print(numberOfItems) # (PortfolioDescription, EvaluationOfRecommenders) portfolioDescr, evaluationOfRecommenders = Input.input01() portfolioDescr, evaluationOfRecommenders = Input.input02() #portfolio:Portfolio portfolio = Portfolio(portfolioDescr) # itemIDs:list<int> itemIDs = portfolio.run(evaluationOfRecommenders, numberOfItems) print(itemIDs)
def portfolio_table(): broker = request.args.get('broker') portfolio = Portfolio(broker_id=int(broker) if broker else None, portfolio_id=1) state_asset, state_cur = portfolio.get_state() items = [] for item in state_asset: ticker, name, quantity, sec_cur, position_orig, position = item items.append({ 'ticker': ticker, 'name': name, 'quantity': quantity, 'sec_cur': sec_cur, 'position_orig': position_orig, 'position': position }) table = PortfolioTable(items, classes=['table', 'table-dark']) return templating.render_template('table.html', table=table)
def create(self, data_source): portfolio = Portfolio() data = data_source.get() snapshots = json.loads(data) for item in snapshots["snapshots"]: portfolio.import_data({ "timestamp": item["timestamp"], "institution": item["institution"], "name": item["account"], "owner": item["owner"], "investment": item["investment"], "update_frequency": item["update_frequency"], "account_type": self.__account_type(item), "value": self.__value(item), "asset_class": self.__asset_class(item), "open_date": item["open_date"], "term": self.__term(item) }) return portfolio
def test_it_returns_the_debt_to_equity_ratio_for_a_portfolio_with_a_mixture_of_accounts_in_nonequal_value( self): asset = AccountBuilder().set_name("name") \ .set_institution("institution") \ .set_owner("owner") \ .set_investment("investment") \ .set_asset_class(AssetClass.NONE) \ .set_account_type(AccountType.ASSET) \ .build() liability = AccountBuilder().set_name("name") \ .set_institution("institution") \ .set_owner("owner") \ .set_investment("investment") \ .set_asset_class(AssetClass.NONE) \ .set_account_type(AccountType.LIABILITY) \ .build() asset.import_snapshot(EpochDateConverter().date_to_epoch(), 1234) liability.import_snapshot(EpochDateConverter().date_to_epoch(), 12345) portfolio = Portfolio() portfolio.import_account(asset) portfolio.import_account(liability) self.assertAlmostEqual( PortfolioAnalyzer(portfolio).debt_to_equity(), 1.1110611)
from datetime import datetime from portfolio.portfolio import Portfolio portfolio = Portfolio(1) start_date = datetime(2019, 11, 20) end_date = datetime.now() portfolio.chart(start_date, end_date, currency=Portfolio.RUB)
def main(): # Bull-Spread implementation example # default market environment market_env = MarketEnvironment() print(market_env) # options strikes K_long = 80 K_short = 110 # bull-spread portfolio initialized (as empty portfolio) bull_spread_ptf = Portfolio(name="Bull Spread Strategy") print(bull_spread_ptf) # 80-call Vanilla_Call_long = PlainVanillaOption(market_env, K=K_long, T='31-12-2021') print(Vanilla_Call_long) # 110-call Vanilla_Call_short = PlainVanillaOption(market_env, K=K_short, T='31-12-2021') print(Vanilla_Call_short) # creation of bull-spread portfolio strategy bull_spread_ptf.add_instrument(Vanilla_Call_long, 1) bull_spread_ptf.add_instrument(Vanilla_Call_short, -1) print(bull_spread_ptf) # portfolio plotter instance bull_spread_ptf_plotter = PortfolioPlotter(bull_spread_ptf) # select dependency to plot as x-axis of the plot # (strike 'K' is skipped because a bull-spread is a multi-strike portfolio) for dependency_type in ["S", "sigma", "r"]: # keyboard parameter and corresponding range to test x_axis_dict = options_x_axis_parameters_factory( bull_spread_ptf, dependency_type) # appropriate azimut angle for best viewing azimut_angle = get_azimut_angle(dependency_type) # select metrics to plot for plot_metrics in [ "price", "PnL", "delta", "theta", "gamma", "vega", "rho" ]: plot_details_flag = True if plot_metrics == "price" else False # Bull-Spread price plot bull_spread_ptf_plotter.plot(**x_axis_dict, t='01-06-2020', plot_metrics=plot_metrics, plot_details=plot_details_flag) for time_kind in ['date', 'tau']: # set time-parameter to plot multiple_valuation_dates = get_time_parameter(bull_spread_ptf, kind=time_kind) print(multiple_valuation_dates) # Plot at multiple dates bull_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics) # Surface plot bull_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True) # Surface plot (rotate) - x-axis side bull_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=( 0, azimut_angle["x-axis side"])) # Price surface plot (rotate) - Date side bull_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0, azimut_angle["Date side"]))
def main(): # # portfolio instantiation example # # if np_output is True, the output will be np.ndarray, otherwise pd.DataFrame np_output = False # True # default market environment market_env = MarketEnvironment(t="01-06-2020") print(market_env) # underlying values to test S_vector = [60, 90, 120] print("S_vector: {}\n".format(S_vector)) # options maturities T_call = "31-12-2020" T_put = "30-06-2021" # options strikes are the same K = 90 K_put = K K_call = K # portfolio options positions call_pos = 2 put_pos = -5 # # Step 0: empty portfolio initialized # ptf = Portfolio() print(ptf) # # Step 1: adding 2 long plain-vanilla call contracts # # plain-vanilla call option opt1_style = "plain_vanilla" # "digital" opt1_type = "call" # "put" call = option_factory(market_env, opt1_style, opt1_type, K=K_call, T=T_call) print(call) # adding contract to portfolio ptf.add_instrument(call, call_pos) print(ptf) # # Step 2: adding 5 short plain-vanilla put contracts # # plain-vanilla put option opt2_style = "plain_vanilla" # "digital" opt2_type = "put" # "call" put = option_factory(market_env, opt2_style, opt2_type, K=K_put, T=T_put) print(put) # plain-vanilla put option put = PlainVanillaOption(market_env, option_type="put", K=K_put, T=T_put) print(put) # adding contract to portfolio ptf.add_instrument(put, put_pos) print(ptf) # # Step 3: portfolio evaluation # for case in ['All_scalar', \ 'S', 'S.sigma_distributed', 'S.r_distributed', 'S.sigma_and_r_distributed', \ 'K', 'K.sigma_distributed', 'K.r_distributed', 'K.sigma_and_r_distributed', \ 't', 't.sigma_distributed', 't.r_distributed', 't.sigma_and_r_distributed', \ 'S.t', 'S.t.sigma_distributed_as_Sxt_grid', 'S.t.r_distributed_as_Sxt_grid', 'S.t.sigma_and_r_distributed_as_Sxt_grid', \ 'K.t', 'K.t.sigma_distributed_as_Kxt_grid', 'K.t.r_distributed_as_Kxt_grid', 'K.t.sigma_and_r_distributed_as_Kxt_grid', \ 't.sigma_axis', 't.r_axis']: # get parameters dictionary for case considered param_dict, case_info = get_param_dict_single_K_ptf( ptf, np_output, case, T=min(T_call, T_put, key=date_string_to_datetime_obj)) print("\n--------------------------------------------\n") print("\n" + case_info + "\n") print("Parameters:") print("S: {}".format(param_dict["S"])) print("K: {}".format(param_dict["K"])) print("t: {}".format(param_dict["t"])) print("sigma: {}".format(param_dict["sigma"])) print("r: {}\n".format(param_dict["r"])) print("Metrics:") # metrics to compare for metrics in [ "price", "PnL", "delta", "theta", "gamma", "vega", "rho" ]: # portfolio metrics ptf_metrics = getattr(ptf, metrics)(**param_dict) print("\nPortfolio {}:\n{}".format(metrics, ptf_metrics)) # verification with benchmark metrics call_metrics = getattr(call, metrics)(**param_dict) put_metrics = getattr(put, metrics)(**param_dict) benchmark_metrics = call_pos * call_metrics + put_pos * put_metrics print("\nBenchmark {}:\n{}".format(metrics, benchmark_metrics)) # check effective match diff = (ptf_metrics - benchmark_metrics).astype('float') num_nonzero_diff = np.count_nonzero(diff) - np.isnan( diff).sum().sum() exact_match = True if num_nonzero_diff == 0 else False print("\nIs replication exact (NaN excluded)? {}\n".format( exact_match))
def main(): # Bull-Spread implementation example # default market environment market_env = MarketEnvironment() print(market_env) # options strikes K_long = 80 K_short = 110 # bull-spread portfolio initialized (as empty portfolio) bull_spread_ptf = Portfolio(name="Bull Spread Strategy") print(bull_spread_ptf) # 80-call Vanilla_Call_long = PlainVanillaOption(market_env, K=K_long, T='31-12-2021') print(Vanilla_Call_long) # 110-call Vanilla_Call_short = PlainVanillaOption(market_env, K=K_short, T='31-12-2021') print(Vanilla_Call_short) # creation of bull-spread portfolio strategy bull_spread_ptf.add_instrument(Vanilla_Call_long, 1) bull_spread_ptf.add_instrument(Vanilla_Call_short, -1) print(bull_spread_ptf) # portfolio plotter instance bull_spread_ptf_plotter = PortfolioPlotter(bull_spread_ptf) # select metrics to plot for plot_metrics in [ "price", "PnL", "delta", "theta", "gamma", "vega", "rho" ]: plot_details_flag = True if plot_metrics == "price" else False # Bull-Spread price plot bull_spread_ptf_plotter.plot(t='01-06-2020', plot_metrics=plot_metrics, plot_details=plot_details_flag) for time_kind in ['date', 'tau']: # set time-parameter to plot multiple_valuation_dates = get_time_parameter(bull_spread_ptf, kind=time_kind) print(multiple_valuation_dates) # Plot at multiple dates bull_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics) # Surface plot bull_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True) # Surface plot (rotate) - Underlying value side bull_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0, 180)) # Price surface plot (rotate) - Date side bull_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0, -90))
pairs = ["EURUSD", "GBPUSD"] # Create the OANDA market price streaming class # making sure to provide authentication commands prices = StreamingForexPrices(settings.STREAM_DOMAIN, settings.ACCESS_TOKEN, settings.ACCOUNT_ID, pairs, events) # Create the strategy/signal generator, passing the # instrument and the events queue strategy = TestStrategy(pairs, events) # Create the portfolio object that will be used to # compare the OANDA positions with the local, to # ensure backtesting integrity. portfolio = Portfolio(prices, events, equity=equity, backtest=False) # Create the execution handler making sure to # provide authentication commands execution = OANDAExecutionHandler(settings.API_DOMAIN, settings.ACCESS_TOKEN, settings.ACCOUNT_ID) # Create two separate threads: One for the trading loop # and another for the market price streaming class trade_thread = threading.Thread(target=trade, args=(events, strategy, portfolio, execution, heartbeat)) price_thread = threading.Thread(target=prices.stream_to_queue, args=[]) # Start both threads
while True: try: event = events.get(False) except queue.Empty: pass else: if event.type == "TICK": strategy.calculate_signals(event) portfolio.update_portfolio(event) elif event.type == "SIGNAL": risk.size_position(event) elif event.type == "ORDER": execution.execute_order(event) if __name__ == "__main__": events = queue.Queue() pairs = ['EURUSD'] stream = DataStream("practice", ACCESS_TOKEN, ACCOUNT_ID, pairs, events) portfolio = Portfolio(stream, events) execution = OandaExecution("practice", ACCESS_TOKEN, ACCOUNT_ID, portfolio) risk = DefaultTestHandler(portfolio, events) strategy = TestStrategy(events) trade_thread = threading.Thread( target=trade, args=(execution, portfolio, risk, strategy, events)) price_thread = threading.Thread(target=stream.stream_to_queue, args=[]) trade_thread.start() price_thread.start()
def main(): # # portfolio instantiation example # # if np_output is True, the output will be np.ndarray, otherwise pd.DataFrame np_output = False # True # default market environment market_env = MarketEnvironment(t="01-06-2020") print(market_env) # underlying values to test S_vector = [60, 90, 120] print("S_vector: {}\n".format(S_vector)) # options maturities T_call = "31-12-2020" T_put = "30-06-2021" # T_call # choose the kind of time-parameter to use: either a date ('date') or a # time-to-maturity ('ttm'). Time-to-maturity time parameter is not allowed # for multi-horizon portfolios. time_parameter = 'date' # 'ttm' # get time parameter t_range = get_time_parameter(market_env, end_date=min(T_call, T_put, key=date_string_to_datetime_obj), periods=5, kind=time_parameter, multi_horizon_ptf=T_call != T_put) # options strikes K_put = 80 K_call = 110 # portfolio options positions call_pos = 2 put_pos = -5 # # Step 0: empty portfolio initialized # ptf = Portfolio() print(ptf) # # Step 1: adding 2 long plain-vanilla call contracts # # plain-vanilla call option call = PlainVanillaOption(market_env, K=K_call, T=T_call) print(call) # adding contract to portfolio ptf.add_instrument(call, call_pos) print(ptf) # metrics to compare for metrics in ["price", "PnL", "delta", "theta", "gamma", "vega", "rho"]: # portfolio metrics ptf_metrics = getattr(ptf, metrics)(S=S_vector, t=t_range, np_output=np_output) print("\nPortfolio {}:\n{}".format(metrics, ptf_metrics)) # verification with benchmark metrics call_metrics = getattr(call, metrics)(S=S_vector, t=t_range, np_output=np_output) benchmark_metrics = call_pos * call_metrics print("\nBenchmark {}:\n{}".format(metrics, benchmark_metrics)) # check effective match diff = (ptf_metrics - benchmark_metrics).astype('float') num_nonzero_diff = np.count_nonzero(diff) - np.isnan(diff).sum().sum() exact_match = True if num_nonzero_diff == 0 else False print( "\nIs replication exact (NaN excluded)? {}\n".format(exact_match)) # # Step 2: adding 5 short plain-vanilla put contracts # # plain-vanilla put option put = PlainVanillaOption(market_env, option_type="put", K=K_put, T=T_put) print(put) # adding contract to portfolio ptf.add_instrument(put, put_pos) print(ptf) # metrics to compare for metrics in ["price", "PnL", "delta", "theta", "gamma", "vega", "rho"]: # portfolio metrics ptf_metrics = getattr(ptf, metrics)(S=S_vector, t=t_range, np_output=np_output) print("\nPortfolio {}:\n{}".format(metrics, ptf_metrics)) # verification with benchmark metrics call_metrics = getattr(call, metrics)(S=S_vector, t=t_range, np_output=np_output) put_metrics = getattr(put, metrics)(S=S_vector, t=t_range, np_output=np_output) benchmark_metrics = call_pos * call_metrics + put_pos * put_metrics print("\nBenchmark {}:\n{}".format(metrics, benchmark_metrics)) # check effective match diff = (ptf_metrics - benchmark_metrics).astype('float') num_nonzero_diff = np.count_nonzero(diff) - np.isnan(diff).sum().sum() exact_match = True if num_nonzero_diff == 0 else False print( "\nIs replication exact (NaN excluded)? {}\n".format(exact_match))
def setUp(self): self.portfolio = Portfolio()
def main(): # Calendar-Spread implementation example # default market environment market_env = MarketEnvironment() print(market_env) # options expirations T_short = "31-05-2020" T_long = "30-08-2020" # current underlying level S_t = market_env.get_S() # calendar-spread portfolio initialized (as empty portfolio) calendar_spread_ptf = Portfolio(name="Calendar Spread Strategy") print(calendar_spread_ptf) # T_long-call Vanilla_Call_long = PlainVanillaOption(market_env, T=T_long, K=S_t) print(Vanilla_Call_long) # T_short-call Vanilla_Call_short = PlainVanillaOption(market_env, T=T_short, K=S_t) print(Vanilla_Call_short) # creation of Calendar-Spread portfolio strategy calendar_spread_ptf.add_instrument(Vanilla_Call_long, 1) calendar_spread_ptf.add_instrument(Vanilla_Call_short, -1) print(calendar_spread_ptf) # portfolio plotter instance calendar_spread_ptf_plotter = PortfolioPlotter(calendar_spread_ptf) # valuation date of the portfolio valuation_date = calendar_spread_ptf.get_t() print(valuation_date) # select dependency to plot as x-axis of the plot for dependency_type in ["S", "K", "sigma", "r"]: # keyboard parameter and corresponding range to test x_axis_dict = options_x_axis_parameters_factory(calendar_spread_ptf, dependency_type) # appropriate azimut angle for best viewing azimut_angle = get_azimut_angle(dependency_type) # select metrics to plot for plot_metrics in ["price", "PnL", "delta", "theta", "gamma", "vega", "rho"]: plot_details_flag = True if plot_metrics == "price" else False # time-parameter as a date-range of 5 valuation dates between t and T_short last_date = T_short if plot_metrics in ["price", "PnL"] else date_string_to_datetime_obj(T_short) - pd.Timedelta(days=1) multiple_valuation_dates = pd.date_range(start=valuation_date, end=last_date, periods=5) print(multiple_valuation_dates) # Bull-Spread price plot calendar_spread_ptf_plotter.plot(**x_axis_dict, t=last_date, plot_metrics=plot_metrics, plot_details=plot_details_flag) # Plot at multiple dates calendar_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics) # Surface plot calendar_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True) # Surface plot (rotate) - Underlying value side calendar_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0,azimut_angle["x-axis side"])) # Price surface plot (rotate) - Date side calendar_spread_ptf_plotter.plot(**x_axis_dict, t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0,azimut_angle["Date side"]))
features = sample_data_features_raw.fillna(method='ffill') features_no_nan = features.dropna() features_final = features_no_nan.drop('side', axis=1).drop('label', axis=1) model = pickle.load(open('randomforestmodel_strat1.sav', 'rb')) sample_data.head() sample_data.Date = pd.to_datetime(sample_data.Date) from portfolio.portfolio import Portfolio from order.order import Order import datetime SMA_portfolio = Portfolio('Strat1', datetime.date, 100000) print(SMA_portfolio.TotalCapital) #we start backtesting from the beginning of the 'test dataset' while training the ML model i = sample_data[sample_data.Date == '2018-12-12 14:21:00'].index[0] while i < len(sample_data.values): print(i) new_data_point = sample_data.loc[i] prev_data_point = sample_data.loc[i - 1] if prev_data_point.MA_5 < prev_data_point.MA_20 and new_data_point.MA_5 > new_data_point.MA_20: new_data_point_features = features_final.loc[ new_data_point.Date].values.reshape(1, -1)
def main(): # Calendar-Spread implementation example # default market environment market_env = MarketEnvironment() print(market_env) # options expirations T_short = "31-05-2020" T_long = "30-08-2020" # current underlying level S_t = market_env.get_S() # calendar-spread portfolio initialized (as empty portfolio) calendar_spread_ptf = Portfolio(name="Calendar Spread Strategy") print(calendar_spread_ptf) # T_long-call Vanilla_Call_long = PlainVanillaOption(market_env, T=T_long, K=S_t) print(Vanilla_Call_long) # T_short-call Vanilla_Call_short = PlainVanillaOption(market_env, T=T_short, K=S_t) print(Vanilla_Call_short) # creation of Calendar-Spread portfolio strategy calendar_spread_ptf.add_instrument(Vanilla_Call_long, 1) calendar_spread_ptf.add_instrument(Vanilla_Call_short, -1) print(calendar_spread_ptf) # portfolio plotter instance calendar_spread_ptf_plotter = PortfolioPlotter(calendar_spread_ptf) # valuation date of the portfolio valuation_date = calendar_spread_ptf.get_t() print(valuation_date) # select metrics to plot for plot_metrics in ["price", "PnL", "delta", "theta", "gamma", "vega", "rho"]: plot_details_flag = True if plot_metrics == "price" else False # time-parameter as a date-range of 5 valuation dates between t and T_short # being the Calendar-Spread a multi-horizon portfolio, time-to-maturity # time parameters are not allowed. last_date = T_short if plot_metrics in ["price", "PnL"] else date_string_to_datetime_obj(T_short) - pd.Timedelta(days=1) multiple_valuation_dates = pd.date_range(start=valuation_date, end=last_date, periods=5) print(multiple_valuation_dates) # Bull-Spread price plot calendar_spread_ptf_plotter.plot(t=last_date, plot_metrics=plot_metrics, plot_details=plot_details_flag) # Plot at multiple dates calendar_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics) # Surface plot calendar_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True) # Surface plot (rotate) - Underlying value side calendar_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0,180)) # Price surface plot (rotate) - Date side calendar_spread_ptf_plotter.plot(t=multiple_valuation_dates, plot_metrics=plot_metrics, surf_plot=True, view=(0,-90))