questraderebalancer

#!/bin/env python3

import argparse
import json
from api.QuestradeApi import QuestradeApi


QUESTRADE_ECN = 0.0035
DOLLAR_COST_AVERAGE = 1.0

questrade_api = QuestradeApi()

DEFAULT_TARGET_RATIOS_FILE = "target_ratios.json"

# Please make sure each account adds to 100
# or this script will not work correctly!

# All symbols under a category will be combined.
# The first will be prioritized for buying and the last for selling.
sample_ratios = {
    'Margin': {
        'CanadianEquity'      : {'ratio': 30, 'symbols':['VCN.TO']},
        'USEquity'            : {'ratio': 30, 'symbols':['XUU.TO']},
        'InternationalEquity' : {'ratio': 23, 'symbols':['XEF.TO']},
        'EmergingEquity'      : {'ratio': 7,  'symbols':['XEC.TO']},
        'CanadianBonds'       : {'ratio': 10, 'symbols':['ZDB.TO']}
    },
    'RRSP': {
        'CanadianEquity'      : {'ratio': 30, 'symbols':['VCN.TO']},
        'USEquity'            : {'ratio': 30, 'symbols':['XUU.TO']},
        'InternationalEquity' : {'ratio': 23, 'symbols':['XEF.TO']},
        'EmergingEquity'      : {'ratio': 7,  'symbols':['XEC.TO']},
        'CanadianBonds'       : {'ratio': 10, 'symbols':['ZAG.TO']}
    },
    'TFSA': {
        'CanadianEquity'      : {'ratio': 30, 'symbols':['VCN.TO']},
        'USEquity'            : {'ratio': 30, 'symbols':['XUU.TO']},
        'InternationalEquity' : {'ratio': 23, 'symbols':['XEF.TO']},
        'EmergingEquity'      : {'ratio': 7,  'symbols':['XEC.TO']},
        'CanadianBonds'       : {'ratio': 10, 'symbols':['ZAG.TO']}
    }
}


def _read_target_ratio_file(path):
    with open(path, 'r') as f:
        return json.load(f)


def _write_target_ratio_file(ratios_dict, path):
    with open(path, 'w') as f:
        json.dump(ratios_dict, f, indent=4, sort_keys=True)
        f.write('\n')


def get_account_targets(path):
    try:
        return _read_target_ratio_file(path)
    except FileNotFoundError:
        target_ratios = sample_ratios
        _write_target_ratio_file(target_ratios, DEFAULT_TARGET_RATIOS_FILE)
        return target_ratios


def get_available_cash(account_id):
    balances = questrade_api.get_balances(account_id)
    cash_balances = balances['perCurrencyBalances']
    for currency in cash_balances:
        if currency['currency'] == 'CAD':
            return currency['cash']

def get_all_symbols(target_ratios):
    return [sym for cat in target_ratios.values() for sym in cat['symbols']]

def get_positions_value(account_id, symbols):
    # Initialize dict to have 0 for each symbol
    positions_value = {symbol: 0 for symbol in symbols}
    positions_total = 0
    positions = questrade_api.get_positions(account_id)
    for position in positions['positions']:
        symbol = position['symbol']
        if symbol in symbols:
            value = float(position['currentMarketValue'])
            positions_value[symbol] = value
            positions_total += value
    return positions_total, positions_value


def get_internal_symbols(symbols):
    symbol_id_dicts = {}
    for symbol in symbols:
        symbol_id = questrade_api.get_id_from_symbol_name(symbol)
        symbol_id_dicts[symbol] = symbol_id
    return symbol_id_dicts


def get_symbol_quotes(symbol_ids):
    quotes = questrade_api.get_market_quotes(symbol_ids)
    return {quote['symbol']: quote['askPrice'] for quote in quotes['quotes']}


def get_best_symbol(positions_total, target_ratios,
                    symbol_quotes, positions_value):

    def calc_r2(ratio1, ratio2):
        diff = ratio1 - ratio2
        return diff ** 2

    def calc_current_r2(position_info):
        position = position_info['position']
        symbol = position_info['to_buy']
        if positions_total == 0:
            current_ratio = 0.0
        else:
            current_ratio = position / float(positions_total)
        target_ratio = position_info['ratio'] / 100.0
        return calc_r2(current_ratio, target_ratio)

    def calc_new_r2(position_info):
        position = position_info['position']
        symbol = position_info['to_buy']
        new_ratio = (position + symbol_quotes[symbol]) / \
                    (positions_total + float(symbol_quotes[symbol]))
        target_ratio = position_info['ratio'] / 100.0
        return calc_r2(new_ratio, target_ratio)

    def calc_r2_diff(position_info):
        curr_r2 = calc_current_r2(position_info)
        new_r2 = calc_new_r2(position_info)
        return new_r2 - curr_r2

    position_info = []
    for category_info in target_ratios.values():
        category_value = sum([positions_value[symbol] for symbol in category_info['symbols']])
        position_info.append(
            {'position': category_value,
             'ratio': category_info['ratio'],
             'to_buy': category_info['symbols'][0],
             'to_sell': category_info['symbols'][-1]})

    r2_diffs = {category_info['to_buy']: calc_r2_diff(category_info)
                for category_info in position_info}
    return min(r2_diffs, key=r2_diffs.get)


# TODO: maybe
def some_tax_loss_harvest():
    pass


# Buy the stock that will minimize the r^2 between current positions ratios and
# target ratios
def something_strategy_1(cash_total, positions_total, target_ratios,
                         symbol_quotes, positions_value):
    to_buy = {}
    remaining = cash_total

    while remaining > QUESTRADE_ECN:
        # Buy the stock which will produce the smallest difference in ratios
        symbol = get_best_symbol(
            positions_total, target_ratios, symbol_quotes, positions_value)
        # Stop if we can't afford the optimum stock
        if not symbol or (symbol_quotes[symbol] + QUESTRADE_ECN) > remaining:
            break
        to_buy[symbol] = to_buy.get(symbol, 0) + 1
        cost_of_symbol = symbol_quotes[symbol]
        remaining -= cost_of_symbol + QUESTRADE_ECN
        positions_total += cost_of_symbol
        positions_value[symbol] += cost_of_symbol

    # Convert into an order list
    order_list = []
    for symbol, quantity in to_buy.items():
        order = {
            'symbol': symbol,
            'quantity': to_buy[symbol],
            'price': symbol_quotes[symbol],
            'action': 'buy'
        }
        order_list.append(order)
    return order_list


# Buy stocks that will minimize the r^2 just from the total cash.
def something_strategy_2(cash_total, target_ratios, symbol_quotes):
    zeroed_positions = {symbol: 0 for symbol in target_ratios.keys()}
    return something_strategy_1(cash_total, 0, target_ratios,
                                symbol_quotes, zeroed_positions)


# TODO: implement
# Buy and sell to rebalance the portfolio
def something_strategy_3(cash_total, positions_total, target_ratios,
                         symbol_quotes, positions_value):
    return []


def display_open_orders(account_type, account_id):
    print("Open orders:")
    print(account_type, account_id)
    open_orders = \
        questrade_api.get_orders(account_id, stateFilter='Open')
    for order in open_orders['orders']:
        action = order['side']
        symbol = order['symbol']
        quantity = order['totalQuantity']
        price = order['limitPrice']
        print("{} {} ({} x {})".format(action, symbol, quantity, price))


def contains_open_conflicting_order(account_id, symbols, verbose=True):
    open_orders = questrade_api.get_orders(account_id, stateFilter='Open')
    conflicting_symbols = []
    for order in open_orders['orders']:
        symbol = order['symbol']
        if symbol in symbols:
            conflicting_symbols.append(symbol)
    if len(conflicting_symbols) == 0:
        return False
    else:
        if verbose:
            for symbol in conflicting_symbols:
                print("There is an open order for {}".format(symbol))
            print("On account".format(account_id))
        return True


# TODO: prioritize sell on strategy 3, don't buy until sold
def place_orders(account_id, internal_symbols, order_list):
    for order in order_list:
        symbol_id = internal_symbols[order['symbol']]
        quantity = order['quantity']
        price = order['price']
        action = order['action']
        buy = action == "buy"
        po = questrade_api.place_order(account_id, symbol_id,
                                       quantity, price, buy=buy)

        if 'rejectReason' in po['orders'][0]:
            reason = po['orders'][0]['rejectReason']
            msg = "Order for {} ({} x {}) was rejected. Reason: {}"
            print(msg.format(symbol, quantity, price, reason))
            break

        print("{} {} ({} x {}) -- Placed successfully".format(action, order['symbol'], quantity, price))


def preview_order(order):
    action = order['action']
    symbol = order['symbol']
    quantity = order['quantity']
    price = order['price']
    total = quantity * price
    fees = QUESTRADE_ECN * quantity
    total_with_fees = total + fees
    print("{} {} ({} x ${}) = ${} + ECN ${} = ${}".format(
        action,
        symbol,
        quantity,
        price,
        round(total, 4),
        round(fees, 4),
        round(total_with_fees, 4)))


def something_rebalance(account_id, target_ratios, strategy=1, preview_only=False):
    # Check if there are conflicting orders
    symbols = get_all_symbols(target_ratios)
    if contains_open_conflicting_order(account_id, symbols, verbose=True):
        return

    cash_total = get_available_cash(account_id) / DOLLAR_COST_AVERAGE
    positions_total, positions_value = get_positions_value(account_id, symbols)

    internal_symbols = get_internal_symbols(symbols)
    symbol_quotes = get_symbol_quotes(list(internal_symbols.values()))

    # Get orders
    if strategy == 1:
        buy_orders = \
            something_strategy_1(cash_total, positions_total, target_ratios,
                                 symbol_quotes, positions_value)
    elif strategy == 2:
        buy_orders = \
            something_strategy_2(cash_total, target_ratios, symbol_quotes)
    elif strategy == 3:
        buy_orders = \
            something_strategy_3(cash_total, positions_total, target_ratios,
                                 symbol_quotes, positions_value)
    else:
        buy_orders = []

    # Preview orders
    cash_remaining = cash_total
    total_spent = 0
    for order in buy_orders:
        preview_order(order)
        spent = round(order['quantity'] * (order['price'] - QUESTRADE_ECN), 4)
        cash_remaining -= spent
        total_spent += spent

    print("Total spent: ${}, Cash remaining: ${}".format(
        round(total_spent, 4),
        round(cash_remaining, 4)))

    if cash_remaining < 0:
        print("Negative cash remaining. Stopping.")
        exit(1)

    # Place orders
    if not preview_only:
        keyword = "CONFIRM"
        msg = "Please type {} in all CAPS to place orders: ".format(keyword)
        confirm_in = input(msg)
        confirmed = confirm_in == keyword

        if not confirmed:
            print("Couldn't confirm confirmation. Stopping")
            exit(1)
        place_orders(account_id, internal_symbols, buy_orders)


description = \
    'Rebalance your Questrade account according to a predefined ratio.'

auth_text = {
    'main': 'Create auth file for Questrade.'
}

show_text = {
    'main': 'Show various information about your account(s).',
    'show_type': 'accounts will display account details, orders will display' +
                 ' all open orders for all accounts.'
}

rebalance_text = {
    'main': "Rebalance your portfolio with various strategies.",
    'account': "The account to rebalance.",
    '--preview-only': "Test run. Doesn\'t place orders.",
    '--strategy': "Set the strategy type when calculating which ETFs/stocks " +
                  "to buy and sell.",
    '--import-ratios': "Path to the ratios file. Defaults to " +
                      "target_ratios.json in the current working directory."
}


parser = argparse.ArgumentParser(description=description)
subparsers = parser.add_subparsers(dest='command')

auth = subparsers.add_parser('auth', help=auth_text['main'])

show = subparsers.add_parser('show', help=show_text['main'])
show.add_argument('show_type', choices=['accounts', 'orders'],
                  help=show_text['show_type'])

rebalance = subparsers.add_parser('rebalance', help=rebalance_text['main'])
rebalance.add_argument('account', help=rebalance_text['account'])
rebalance.add_argument('--preview-only', action='store_true',
                       help=rebalance_text['--preview-only'])
rebalance.add_argument('--strategy', type=int, default=1,
                       choices=range(1, 4),
                       help=rebalance_text['--strategy'])
rebalance.add_argument('--import-ratios', default=DEFAULT_TARGET_RATIOS_FILE,
                       help=rebalance_text['--import-ratios'])

args = parser.parse_args()


def main():
    try:
        get_accounts = questrade_api.get_accounts()['accounts']
        accounts = {account['type']: account['number']
                    for account in get_accounts}
        authenticated = True
    except AttributeError:
        authenticated = False
    except KeyError:
        authenticated = False

    if authenticated:
        if args.command == "show":
            if args.show_type == "accounts":
                for account_type, account_id in accounts.items():
                    print(account_type, account_id)
            elif args.show_type == "orders":
                for account in accounts.items():
                    display_open_orders(*account)
        elif args.command == "rebalance":
            target_ratios = get_account_targets(args.import_ratios)
            account_id = accounts[args.account]
            specific_account_ratios = target_ratios[args.account]
            something_rebalance(account_id, specific_account_ratios,
                                args.strategy, args.preview_only)
    else:
        if args.command == "auth":
            questrade_api.auth()
        else:
            print("Not authenticated, please run {} auth".format(__file__))


if __name__ == "__main__":
    main()