Encapsulate Trailing and Stop

algobot/enums.py

@@ -1,4 +1,5 @@
 # TODO: Add unit tests.
+from typing import Optional
 
 BULLISH = 1
 BEARISH = -1
@@ -17,8 +18,31 @@ class GraphType:
 LONG = 1
 SHORT = -1
 
-TRAILING = 2
-STOP = 1
+
+class OrderType:
+ TRAILING = 2
+ STOP = 1
+
+ @staticmethod
+ def from_str(value: str) -> int:
+ if value.lower() == "trailing":
+ return OrderType.TRAILING
+ elif value.lower() == "stop":
+ return OrderType.STOP
+ else:
+ raise ValueError(f"{value} is unsupported")
+
+ @staticmethod
+ def to_str(order_type: Optional[int]) -> str:
+ if order_type == OrderType.STOP:
+ return "Stop"
+ elif order_type == OrderType.TRAILING:
+ return "Trailing"
+ elif order_type is None:
+ return "None"
+ else:
+ raise ValueError(f"Unknown OrderType with value {order_type}")
+
 
 BACKTEST = 2
 SIMULATION = 3

algobot/interface/configuration.py

@@ -7,7 +7,7 @@
  QLabel, QLayout, QMainWindow, QSpinBox,
  QTabWidget)
 
-from algobot.enums import BACKTEST, LIVE, OPTIMIZER, SIMULATION, STOP, TRAILING
+from algobot.enums import BACKTEST, LIVE, OPTIMIZER, SIMULATION, OrderType
 from algobot.graph_helpers import create_infinite_line
 from algobot.helpers import ROOT_DIR
 from algobot.interface.config_utils.credential_utils import load_credentials
@@ -344,9 +344,9 @@ def get_take_profit_settings(self, caller) -> dict:
  dictionary = self.takeProfitDict
  if dictionary[tab, 'groupBox'].isChecked():
  if dictionary[tab, 'takeProfitType'].currentText() == "Trailing":
- takeProfitType = TRAILING
+ takeProfitType = OrderType.TRAILING
  else:
- takeProfitType = STOP
+ takeProfitType = OrderType.STOP
  else:
  takeProfitType = None
 
@@ -381,21 +381,22 @@ def get_loss_settings(self, caller: int) -> dict:
  tab = self.get_category_tab(caller)
  dictionary = self.lossDict
  if dictionary[tab, 'groupBox'].isChecked():
- lossType = TRAILING if dictionary[tab, "lossType"].currentText() == "Trailing" else STOP
+ loss_type = dictionary[tab, "lossType"].currentText()
+ loss_strategy = OrderType.TRAILING if loss_type == "Trailing" else OrderType.STOP
  else:
- lossType = None
+ loss_strategy = None
 
- lossSettings = {
- 'lossType': lossType,
+ loss_settings = {
+ 'lossType': loss_strategy,
  'lossTypeIndex': dictionary[tab, "lossType"].currentIndex(),
  'lossPercentage': dictionary[tab, 'lossPercentage'].value(),
  'smartStopLossCounter': dictionary[tab, 'smartStopLossCounter'].value()
  }
 
  if tab != self.backtestConfigurationTabWidget:
- lossSettings['safetyTimer'] = dictionary[tab, 'safetyTimer'].value()
+ loss_settings['safetyTimer'] = dictionary[tab, 'safetyTimer'].value()
 
- return lossSettings
+ return loss_settings
 
  def add_strategy_to_config(self, caller: int, strategyName: str, config: dict):
  """

algobot/traders/backtester.py

@@ -12,7 +12,8 @@
 from dateutil import parser
 
 from algobot.enums import (BACKTEST, BEARISH, BULLISH, ENTER_LONG, ENTER_SHORT,
- EXIT_LONG, EXIT_SHORT, LONG, OPTIMIZER, SHORT)
+ EXIT_LONG, EXIT_SHORT, LONG, OPTIMIZER, SHORT,
+ OrderType)
 from algobot.helpers import (LOG_FOLDER, ROOT_DIR,
  convert_all_dates_to_datetime,
  convert_small_interval, get_interval_minutes,
@@ -442,7 +443,7 @@ def get_basic_optimize_info(self, run: int, totalRuns: int, result: str = 'PASSE
  round(self.get_net() / self.startingBalance * 100 - 100, 2),
  self.get_stop_loss_strategy_string(),
  self.get_safe_rounded_string(self.lossPercentageDecimal, multiplier=100, symbol='%'),
- self.get_trailing_or_stop_type_string(self.takeProfitType),
+ OrderType.to_str(self.takeProfitType),
  self.get_safe_rounded_string(self.takeProfitPercentageDecimal, multiplier=100, symbol='%'),
  self.symbol,
  self.interval,
@@ -479,11 +480,11 @@ def apply_general_settings(self, settings: Dict[str, Union[float, str, dict]]):
  :param settings: Dictionary with keys and values to set.
  """
  if 'takeProfitType' in settings:
- self.takeProfitType = self.get_enum_from_str(settings['takeProfitType'])
+ self.takeProfitType = OrderType.from_str(settings['takeProfitType'])
  self.takeProfitPercentageDecimal = settings['takeProfitPercentage'] / 100
 
  if 'lossType' in settings:
- self.lossStrategy = self.get_enum_from_str(settings['lossType'])
+ self.lossStrategy = OrderType.from_str(settings['lossType'])
  self.lossPercentageDecimal = settings['lossPercentage'] / 100
 
  if 'stopLossCounter' in settings:

algobot/traders/simulationtrader.py

@@ -5,7 +5,7 @@
 
 from algobot.data import Data
 from algobot.enums import (BEARISH, BULLISH, ENTER_LONG, ENTER_SHORT,
- EXIT_LONG, EXIT_SHORT, LONG, SHORT)
+ EXIT_LONG, EXIT_SHORT, LONG, SHORT, OrderType)
 from algobot.helpers import convert_small_interval, get_logger
 from algobot.traders.trader import Trader
 
@@ -107,7 +107,7 @@ def get_grouped_statistics(self) -> dict:
 
  if self.takeProfitType is not None:
  groupedDict['takeProfit'] = {
- 'takeProfitType': self.get_trailing_or_stop_type_string(self.takeProfitType),
+ 'takeProfitType': OrderType.to_str(self.takeProfitType),
  'takeProfitPercentage': self.get_safe_rounded_percentage(self.takeProfitPercentageDecimal),
  'trailingTakeProfitActivated': str(self.trailingTakeProfitActivated),
  'takeProfitPoint': self.get_safe_rounded_string(self.takeProfitPoint),

algobot/traders/trader.py

@@ -5,7 +5,7 @@
 from typing import Dict, List, Union
 
 from algobot.enums import (BEARISH, BULLISH, ENTER_LONG, ENTER_SHORT,
- EXIT_LONG, EXIT_SHORT, LONG, SHORT, STOP, TRAILING)
+ EXIT_LONG, EXIT_SHORT, LONG, SHORT, OrderType)
 from algobot.helpers import get_label_string, parse_strategy_name
 from algobot.strategies.strategy import Strategy
 
@@ -224,16 +224,16 @@ def get_stop_loss(self):
  if self.currentPosition == SHORT:
  if self.smartStopLossEnter and self.previousStopLoss > self.currentPrice:
  self.stopLoss = self.previousStopLoss
- elif self.lossStrategy == TRAILING:
+ elif self.lossStrategy == OrderType.TRAILING:
  self.stopLoss = self.shortTrailingPrice * (1 + self.lossPercentageDecimal)
- elif self.lossStrategy == STOP:
+ elif self.lossStrategy == OrderType.STOP:
  self.stopLoss = self.sellShortPrice * (1 + self.lossPercentageDecimal)
  elif self.currentPosition == LONG:
  if self.smartStopLossEnter and self.previousStopLoss < self.currentPrice:
  self.stopLoss = self.previousStopLoss
- elif self.lossStrategy == TRAILING:
+ elif self.lossStrategy == OrderType.TRAILING:
  self.stopLoss = self.longTrailingPrice * (1 - self.lossPercentageDecimal)
- elif self.lossStrategy == STOP:
+ elif self.lossStrategy == OrderType.STOP:
  self.stopLoss = self.buyLongPrice * (1 - self.lossPercentageDecimal)
 
  if self.stopLoss is not None: # This is for the smart stop loss to reenter position.
@@ -246,9 +246,9 @@ def get_stop_loss_strategy_string(self) -> str:
  Returns stop loss strategy in string format, instead of integer enum.
  :return: Stop loss strategy in string format.
  """
- if self.lossStrategy == STOP:
+ if self.lossStrategy == OrderType.STOP:
  return 'Stop Loss'
- elif self.lossStrategy == TRAILING:
+ elif self.lossStrategy == OrderType.TRAILING:
  return 'Trailing Loss'
  elif self.lossStrategy is None:
  return 'None'
@@ -320,28 +320,6 @@ def get_profit_percentage(initialNet: float, finalNet: float) -> float:
  else:
  return -1 * (100 - finalNet / initialNet * 100)
 
- @staticmethod
- def get_trailing_or_stop_type_string(stopType: Union[int, None]) -> str:
- """
- Returns stop type in string format instead of integer enum.
- :return: Stop type in string format.
- """
- if stopType == STOP:
- return 'Stop'
- elif stopType == TRAILING:
- return 'Trailing'
- elif stopType is None:
- return 'None'
- else:
- raise ValueError("Unknown type of exit position type.")
-
- @staticmethod
- def get_enum_from_str(string):
- if string.lower() == "trailing":
- return TRAILING
- elif string.lower() == 'stop':
- return STOP
-
  @staticmethod
  def get_trend_string(trend) -> str:
  """
@@ -436,12 +414,12 @@ def get_take_profit(self) -> Union[float, None]:
  return None
 
  if self.currentPosition == SHORT:
- if self.takeProfitType == STOP:
+ if self.takeProfitType == OrderType.STOP:
  self.takeProfitPoint = self.sellShortPrice * (1 - self.takeProfitPercentageDecimal)
  else:
  raise ValueError("Invalid type of take profit type provided.")
  elif self.currentPosition == LONG:
- if self.takeProfitType == STOP:
+ if self.takeProfitType == OrderType.STOP:
  self.takeProfitPoint = self.buyLongPrice * (1 + self.takeProfitPercentageDecimal)
  else:
  raise ValueError("Invalid type of take profit type provided.")

tests/test_backtester.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from algobot.enums import LONG, SHORT, STOP, TRAILING
+from algobot.enums import LONG, SHORT, OrderType
 from algobot.helpers import convert_all_dates_to_datetime, load_from_csv
 from algobot.traders.backtester import Backtester
 
@@ -25,8 +25,8 @@ def setUp(self) -> None:
  symbol="1INCHUSDT",
  marginEnabled=True,
  )
- self.backtester.apply_take_profit_settings({'takeProfitType': TRAILING, 'takeProfitPercentage': 5})
- self.backtester.apply_loss_settings({'lossType': TRAILING, 'lossPercentage': 5})
+ self.backtester.apply_take_profit_settings({'takeProfitType': OrderType.TRAILING, 'takeProfitPercentage': 5})
+ self.backtester.apply_loss_settings({'lossType': OrderType.TRAILING, 'lossPercentage': 5})
 
  def test_initialization(self):
  """
@@ -281,39 +281,39 @@ def test_long_stop_loss(self):
  Test backtester stop loss logic in a long position.
  """
  backtester = self.backtester
- backtester.lossStrategy = STOP
+ backtester.lossStrategy = OrderType.STOP
  backtester.set_priced_current_price_and_period(5)
  backtester.buy_long("Test purchase.")
  self.assertEqual(backtester.get_stop_loss(), 5 * (1 - backtester.lossPercentageDecimal))
 
  backtester.set_priced_current_price_and_period(10)
  self.assertEqual(backtester.get_stop_loss(), 5 * (1 - backtester.lossPercentageDecimal))
 
- backtester.lossStrategy = TRAILING
+ backtester.lossStrategy = OrderType.TRAILING
  self.assertEqual(backtester.get_stop_loss(), 10 * (1 - backtester.lossPercentageDecimal))
 
  def test_short_stop_loss(self):
  """
  Test backtester stop loss logic in a short position.
  """
  backtester = self.backtester
- backtester.lossStrategy = STOP
+ backtester.lossStrategy = OrderType.STOP
  backtester.set_priced_current_price_and_period(5)
  backtester.sell_short("Test short.")
  self.assertEqual(backtester.get_stop_loss(), 5 * (1 + backtester.lossPercentageDecimal))
 
  backtester.set_priced_current_price_and_period(3)
  self.assertEqual(backtester.get_stop_loss(), 5 * (1 + backtester.lossPercentageDecimal))
 
- backtester.lossStrategy = TRAILING
+ backtester.lossStrategy = OrderType.TRAILING
  self.assertEqual(backtester.get_stop_loss(), 3 * (1 + backtester.lossPercentageDecimal))
 
  def test_stop_take_profit(self):
  """
  Test backtester take profit logic.
  """
  backtester = self.backtester
- backtester.takeProfitType = STOP
+ backtester.takeProfitType = OrderType.STOP
  backtester.set_priced_current_price_and_period(10)
  backtester.buy_long("Test purchase.")
  self.assertEqual(backtester.get_take_profit(), 10 * (1 + backtester.takeProfitPercentageDecimal))

tests/test_base_trader.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from algobot.enums import BEARISH, BULLISH, LONG, SHORT, STOP, TRAILING
+from algobot.enums import BEARISH, BULLISH, LONG, SHORT, OrderType
 from algobot.strategies.strategy import Strategy
 from algobot.traders.trader import Trader
 
@@ -149,30 +149,30 @@ def test_set_safety_timer(self):
  def test_apply_take_profit_settings(self):
  take_profit_settings = {
  'takeProfitPercentage': 25,
- 'takeProfitType': STOP
+ 'takeProfitType': OrderType.STOP
  }
  self.trader.apply_take_profit_settings(take_profit_settings)
 
  self.assertEqual(self.trader.takeProfitPercentageDecimal, 0.25)
- self.assertEqual(self.trader.takeProfitType, STOP)
+ self.assertEqual(self.trader.takeProfitType, OrderType.STOP)
 
  def test_apply_loss_settings(self):
  loss_settings = {
- 'lossType': STOP,
+ 'lossType': OrderType.STOP,
  'lossPercentage': 5.5,
  'smartStopLossCounter': 15,
  'safetyTimer': 45
  }
  self.trader.apply_loss_settings(loss_settings)
 
- self.assertEqual(self.trader.lossStrategy, STOP)
+ self.assertEqual(self.trader.lossStrategy, OrderType.STOP)
  self.assertEqual(self.trader.lossPercentageDecimal, 0.055)
  self.assertEqual(self.trader.smartStopLossInitialCounter, 15)
  self.assertEqual(self.trader.smartStopLossCounter, 15)
  self.assertEqual(self.trader.safetyTimer, 45)
 
  def test_get_stop_loss(self):
- self.trader.lossStrategy = STOP
+ self.trader.lossStrategy = OrderType.STOP
  self.trader.lossPercentageDecimal = 0.1
  self.trader.currentPrice = 5
 
@@ -190,10 +190,10 @@ def test_get_stop_loss(self):
  # TODO implement trailing stop loss test
 
  def test_get_stop_loss_strategy_string(self):
- self.trader.lossStrategy = STOP
+ self.trader.lossStrategy = OrderType.STOP
  self.assertEqual(self.trader.get_stop_loss_strategy_string(), "Stop Loss")
 
- self.trader.lossStrategy = TRAILING
+ self.trader.lossStrategy = OrderType.TRAILING
  self.assertEqual(self.trader.get_stop_loss_strategy_string(), "Trailing Loss")
 
  self.trader.lossStrategy = None
@@ -273,11 +273,6 @@ def test_get_profit_percentage(self):
  self.assertEqual(self.trader.get_profit_percentage(100, 50), -50)
  self.assertEqual(self.trader.get_profit_percentage(100, 130), 30)
 
- def test_get_trailing_or_stop_loss_string(self):
- self.assertEqual(self.trader.get_trailing_or_stop_type_string(STOP), 'Stop')
- self.assertEqual(self.trader.get_trailing_or_stop_type_string(TRAILING), 'Trailing')
- self.assertEqual(self.trader.get_trailing_or_stop_type_string(None), 'None')
-
  def test_get_trend_string(self):
  self.assertEqual(self.trader.get_trend_string(None), str(None))
  self.assertEqual(self.trader.get_trend_string(BEARISH), "Bearish")
@@ -321,7 +316,7 @@ def test_get_safe_rounded_string(self):
  multiplier=5), '6.15*')
 
  def test_get_take_profit(self):
- self.trader.takeProfitType = STOP
+ self.trader.takeProfitType = OrderType.STOP
  self.trader.takeProfitPercentageDecimal = 0.05
 
  self.trader.currentPosition = LONG

tests/test_enums.py

@@ -0,0 +1,22 @@
+import unittest
+
+from algobot.enums import OrderType
+
+
+class OrderTypeTest(unittest.TestCase):
+ def test_from_str(self):
+ self.assertEqual(OrderType.from_str("Stop"), OrderType.STOP)
+ self.assertEqual(OrderType.from_str("Trailing"), OrderType.TRAILING)
+
+ def test_from_str_unsupported(self):
+ with self.assertRaises(ValueError):
+ OrderType.from_str("Random")
+
+ def test_to_str(self):
+ self.assertEqual(OrderType.to_str(OrderType.STOP), "Stop")
+ self.assertEqual(OrderType.to_str(OrderType.TRAILING), "Trailing")
+ self.assertEqual(OrderType.to_str(None), "None")
+
+ def test_to_str_unsupported(self):
+ with self.assertRaises(ValueError):
+ OrderType.to_str(100)