Documented the market system properly, squashed some bugs

core/exchanges/oanda.py

@@ -54,7 +54,7 @@ class OANDAExchange(BaseExchange):
                 # "price": "1.5000", - added later
                 "stopLossOnFill": {"timeInForce": "GTC", "price": str(trade.stop_loss)},
                 "takeProfitOnFill": {"price": str(trade.take_profit)},
-                # "timeInForce": "GTC",
+                "timeInForce": "GTC",
                 "instrument": trade.symbol,
                 "units": str(amount),
                 "type": trade.type.upper(),

core/lib/market.py

@@ -1,7 +1,7 @@
 from decimal import Decimal as D
 
 from core.exchanges import GenericAPIError
-from core.models import Strategy, Trade
+from core.models import Account, Strategy, Trade
 from core.util import logs
 
 log = logs.get_logger(__name__)
@@ -16,132 +16,230 @@ log = logs.get_logger(__name__)
 #     prices = account.client.get_currencies([symbol])
 
 
-def to_currency(direction, account, amount, from_currency, to_currency):
+def get_pair(account, base, quote, invert=False):
+    """
+    Get the pair for the given account and currencies.
+    :param account: Account object
+    :param base: Base currency
+    :param quote: Quote currency
+    :param invert: Invert the pair
+    :return: currency symbol, e.g. BTC_USD, BTC/USD, etc.
+    """
+    # Currently we only have two exchanges with different pair separators
     if account.exchange == "alpaca":
         separator = "/"
     elif account.exchange == "oanda":
         separator = "_"
+
+    # Flip the pair if needed
+    if invert:
+        symbol = f"{quote.upper()}{separator}{base.upper()}"
+    else:
+        symbol = f"{base.upper()}{separator}{quote.upper()}"
+    # Check it exists
+    if symbol not in account.supported_symbols:
+        return False
+    return symbol
+
+
+def to_currency(direction, account, amount, from_currency, to_currency):
+    """
+    Convert an amount from one currency to another.
+    :param direction: Direction of the trade
+    :param account: Account object
+    :param amount: Amount to convert
+    :param from_currency: Currency to convert from
+    :param to_currency: Currency to convert to
+    :return: Converted amount
+    """
+    # This is needed because OANDA has different values for bid and ask
     if direction == "buy":
         price_index = "bids"
     elif direction == "sell":
         price_index = "asks"
-    symbol = f"{from_currency.upper()}{separator}{to_currency.upper()}"
+    symbol = get_pair(account, from_currency, to_currency)
-    if symbol not in account.supported_symbols:
+    if not symbol:
-        symbol = f"{to_currency.upper()}{separator}{from_currency.upper()}"
+        symbol = get_pair(account, from_currency, to_currency, invert=True)
         inverted = True
+
+        # Bit of a hack but it works
+        if not symbol:
+            log.error(f"Could not find symbol for {from_currency} -> {to_currency}")
+            raise Exception("Could not find symbol")
     try:
         prices = account.client.get_currencies([symbol])
     except GenericAPIError as e:
         log.error(f"Error getting currencies and inverted currencies: {e}")
         return None
     price = prices["prices"][0][price_index][0]["price"]
+
+    # If we had to flip base and quote, we need to use the reciprocal of the price
     if inverted:
         price = D(1.0) / D(price)
+
+    # Convert the amount to the destination currency
     converted = D(amount) * price
 
     return converted
 
 
-def get_pair(account, base, quote):
+def get_trade_size_in_base(direction, account, strategy, cash_balance, base):
-    if account.exchange == "alpaca":
+    """
-        separator = "/"
+    Get the trade size in the base currency.
-    elif account.exchange == "oanda":
+    :param direction: Direction of the trade
-        separator = "_"
+    :param account: Account object
+    :param strategy: Strategy object
+    :param cash_balance: Cash balance in the Account's base currency
+    :param base: Base currency
+    :return: Trade size in the base currency
+    """
 
-    symbol = f"{base.upper()}{separator}{quote.upper()}"
+    # Convert the trade size in percent to a ratio
-    if symbol not in account.supported_symbols:
-        return False
-    return symbol
-
-
-def get_trade_size_in_base(
-    direction, account, strategy, cash_balance, price, base, precision
-):
     trade_size_as_ratio = D(strategy.trade_size_percent) / D(100)
     log.debug(f"Trade size as ratio: {trade_size_as_ratio}")
+
+    # Multiply with cash balance to get the trade size in the account's
+    # base currency
     amount_fiat = D(trade_size_as_ratio) * D(cash_balance)
     log.debug(f"Trade size: {amount_fiat}")
-    # We can do this because the quote IS in $ or equivalent
+
-    # trade_size_in_base = D(amount_fiat) / D(price)
+    # Convert the trade size to the base currency
     trade_size_in_base = to_currency(
         direction, account, amount_fiat, account.currency, base
     )
     log.debug(f"Trade size in base: {trade_size_in_base}")
+
     return trade_size_in_base
 
 
 def get_tp_sl(direction, strategy, price):
+    """
+    Get the take profit and stop loss prices.
+    :param direction: Direction of the trade
+    :param strategy: Strategy object
+    :param price: Price of the trade
+    :return: Take profit and stop loss prices
+    """
+
+    # Convert TP and SL to ratios
     stop_loss_as_ratio = D(strategy.stop_loss_percent) / D(100)
     take_profit_as_ratio = D(strategy.take_profit_percent) / D(100)
     log.debug(f"Stop loss as ratio: {stop_loss_as_ratio}")
     log.debug(f"Take profit as ratio: {take_profit_as_ratio}")
 
+    # Calculate the TP and SL prices by multiplying with the price
     stop_loss_var = D(price) * D(stop_loss_as_ratio)
     take_profit_var = D(price) * D(take_profit_as_ratio)
     log.debug(f"Stop loss var: {stop_loss_var}")
     log.debug(f"Take profit var: {take_profit_var}")
 
+    # Flip addition operators for inverse trade directions
+    # * We need to subtract the SL for buys, since we are losing money if
+    # the price goes down
+    # * We need to add the TP for buys, since we are gaining money if
+    # the price goes up
+    # * We need to add the SL for sells, since we are losing money if
+    # the price goes up
+    # * We need to subtract the TP for sells, since we are gaining money if
+    # the price goes down
     if direction == "buy":
         stop_loss = D(price) - D(stop_loss_var)
         take_profit = D(price) + D(take_profit_var)
     elif direction == "sell":
         stop_loss = D(price) + D(stop_loss_var)
         take_profit = D(price) - D(take_profit_var)
-
     log.debug(f"Stop loss: {stop_loss}")
     log.debug(f"Take profit: {take_profit}")
+
     return (stop_loss, take_profit)
 
 
 def get_price_bound(direction, strategy, price):
+    """
+    Get the price bound for a given price using the slippage from the strategy.
+    :param direction: Direction of the trade
+    :param strategy: Strategy object
+    :param price: Price of the trade
+    :return: Price bound
+    """
+
+    # Convert the slippage to a ratio
     price_slippage_as_ratio = D(strategy.price_slippage_percent) / D(100)
     log.debug(f"Price slippage as ratio: {price_slippage_as_ratio}")
-    price_slippage = D(price) * D(price_slippage_as_ratio)
 
+    # Calculate the price bound by multiplying with the price
+    # The price bound is the worst price we are willing to pay for the trade
+    price_slippage = D(price) * D(price_slippage_as_ratio)
     log.debug(f"Price slippage: {price_slippage}")
 
+    # Subtract slippage for buys, since we lose money if the price goes down
     if direction == "buy":
         price_bound = D(price) - D(price_slippage)
+
+    # Add slippage for sells, since we lose money if the price goes up
     elif direction == "sell":
         price_bound = D(price) + D(price_slippage)
-    price_bound = D(price) + D(price_slippage)
-
     log.debug(f"Price bound: {price_bound}")
     return price_bound
 
 
 def execute_strategy(callback, strategy):
+    """
+    Execute a strategy.
+    :param callback: Callback object
+    :param strategy: Strategy object
+    """
+
+    # Get the account's balance in the native account currency
     cash_balance = strategy.account.client.get_balance()
-    instruments = strategy.account.instruments
     log.debug(f"Cash balance: {cash_balance}")
 
+    # Instruments supported by the account
+    if not strategy.account.instruments:
+        strategy.account.update_info()
+        # Refresh account object
+        strategy.account = Account.objects.get(id=strategy.account.id)
+
+    instruments = strategy.account.instruments
+    if not instruments:
+        log.error("No instruments found")
+        return
+
+    # Shorten some hook, strategy and callback vars for convenience
     user = strategy.user
     account = strategy.account
     hook = callback.hook
     base = callback.base
     quote = callback.quote
     direction = hook.direction
+
+    # Don't be silly
     if callback.exchange != account.exchange:
         log.error("Market exchange differs from account exchange.")
         return
 
+    # Get the pair we are trading
     symbol = get_pair(account, base, quote)
-
     if not symbol:
         log.error(f"Symbol not supported by account: {symbol}")
-        return False
+        return
 
+    print("INSTRUMENTS", instruments)
+    # Extract the information for the symbol
     instrument = strategy.account.client.extract_instrument(instruments, symbol)
     if not instrument:
         log.error(f"Symbol not found: {symbol}")
-        return False
+        return
+
+    # Get the required precision
     try:
         trade_precision = instrument["tradeUnitsPrecision"]
         display_precision = instrument["displayPrecision"]
     except KeyError:
         log.error(f"Precision not found for {symbol}")
-        return False
+        return
 
+    # Round the received price to the display precision
     price = round(D(callback.price), display_precision)
     log.debug(f"Extracted price of quote: {price}")
 
@@ -152,15 +250,36 @@ def execute_strategy(callback, strategy):
     #     return False
 
     # type = "limit"
-    type = "market"
 
+    # Only using market orders for now, but with price bounds, so it's a similar
+    # amount of protection from market fluctuations
+    # type = "market"
+
+    # For OANDA we can use the price since it should match exactly
+    # Not yet sure how to use both limit and market orders
+    type = "limit"
+
+    # Convert the trade size, which is currently in the account's base currency,
+    # to the base currency of the pair we are trading
     trade_size_in_base = get_trade_size_in_base(
-        direction, account, strategy, cash_balance, price, base, display_precision
+        direction, account, strategy, cash_balance, base
     )
+
+    # Calculate TP/SL
     stop_loss, take_profit = get_tp_sl(direction, strategy, price)
 
+    # Calculate price bound and round to the display precision
     price_bound = round(get_price_bound(direction, strategy, price), display_precision)
 
+    # Use the price reported by the callback for limit orders
+    if type == "limit":
+        price_for_trade = price
+
+    # Use the price bound for market orders
+    elif type == "market":
+        price_for_trade = price_bound
+
+    # Create object, note that the amount is rounded to the trade precision
     new_trade = Trade.objects.create(
         user=user,
         account=account,
@@ -169,7 +288,8 @@ def execute_strategy(callback, strategy):
         type=type,
         # amount_fiat=amount_fiat,
         amount=float(round(trade_size_in_base, trade_precision)),
-        price=price_bound,
+        # price=price_bound,
+        price=price_for_trade,
         stop_loss=float(round(stop_loss, display_precision)),
         take_profit=float(round(take_profit, display_precision)),
         direction=direction,

core/models.py

@@ -86,10 +86,7 @@ class Account(models.Model):
             name += " (sandbox)"
         return name
 
-    def save(self, *args, **kwargs):
+    def update_info(self, save=True):
-        """
-        Override the save function to update supported symbols.
-        """
         client = self.get_client()
         if client:
             response = client.get_instruments()
@@ -99,6 +96,14 @@ class Account(models.Model):
             self.supported_symbols = supported_symbols
             self.instruments = response
             self.currency = currency
+        if save:
+            self.save()
+
+    def save(self, *args, **kwargs):
+        """
+        Override the save function to update supported symbols.
+        """
+        self.update_info(save=False)
         super().save(*args, **kwargs)
 
     def get_client(self):