refactoring strategy registration, fixing configs

Author: timkpaine

algocoin/lib/config.py

@@ -5,7 +5,7 @@
 @config
 class ExchangeConfig:
     exchange_type = ExchangeType, ExchangeType.NONE
-    exchange_types = [ExchangeType], [ExchangeType.NONE]
+    exchange_types = [ExchangeType], []
     trading_type = TradingType, TradingType.NONE
 
 
@@ -29,7 +29,7 @@ class ExecutionConfig:
 
 @config
 class StrategyConfig:
-    classname = str, ''
+    clazz = type
     args = tuple, ()
     kwargs = dict, {}
 
@@ -42,4 +42,4 @@ class TradingEngineConfig:
     backtest_options = BacktestConfig, BacktestConfig()
     risk_options = RiskConfig, RiskConfig()
     execution_options = ExecutionConfig, ExecutionConfig()
-    strategy_options = [StrategyConfig], [StrategyConfig()]  # List of strategy options
+    strategy_options = [StrategyConfig], []  # List of strategy options

algocoin/lib/parser.py

@@ -1,5 +1,6 @@
 from configparser import ConfigParser
-from .config import TradingEngineConfig, BacktestConfig
+from pydoc import locate
+from .config import TradingEngineConfig, BacktestConfig, StrategyConfig
 from .enums import TradingType
 from .exceptions import ConfigException
 from .utils import str_to_exchange, exchange_to_file, set_verbose
@@ -63,8 +64,19 @@ def _parse_exchange(exchange, config) -> None:
 
 
 def _parse_strategy(strategy, config) -> None:
-    # TODO
-    pass
+    strat_configs = []
+
+    if 'strategies' not in strategy:
+        raise Exception('No Strategies specified')
+
+    for strat in strategy['strategies'].split('\n'):
+        if strat == '':
+            continue
+        splits = [x for x in strat.split(',') if x]
+        cls = locate(splits[0])
+        args = tuple(splits[1:]) if len(splits) > 1 else ()
+        strat_configs.append(StrategyConfig(clazz=cls, args=args))
+    config.strategy_options = strat_configs
 
 
 def _parse_risk(risk, config) -> None:
@@ -114,12 +126,16 @@ def _parse_sandbox_options(argv, config) -> None:
 
 def _parse_backtest_options(argv, config) -> None:
     log.critical("Backtesting")
+
     config.backtest_options = BacktestConfig()
+
     config.backtest_options.file = \
         exchange_to_file(str_to_exchange(argv.get('exchange', '')))
+
     config.exchange_options.exchange_type = \
         str_to_exchange(argv.get('exchange', ''))
-    config.risk_options.total_funds = 20000.0
+
+    config.risk_options.total_funds = 20000.0  # FIXME
 
 
 def parse_command_line_config(argv: list) -> TradingEngineConfig:

algocoin/lib/utils.py

@@ -20,10 +20,10 @@ def create_pair(key: str, typ: type, default=None, container=None) -> property:
     def get(self):
         if hasattr(self, '__' + str(key)):
             return getattr(self, '__' + str(key))
-        if default is not None and type(default) == typ:
+        if default is not None and (type(default) == typ or (container == list and (default == [] or type(default[0]) == typ))):
             if container:
                 if container == list:
-                    return [default]
+                    return default
                 else:
                     raise TypeError('Unrecognized container: %s',
                                     str(container))
@@ -53,33 +53,55 @@ def config(cls):
     vars = []
     for k, v in cls.__dict__.items():
         if isinstance(v, type):
+            # V is a type, no default value
             v = create_pair(k, v)
             vars.append(k)
         elif isinstance(v, tuple) and \
                 isinstance(v[0], type) and \
                 isinstance(v[1], v[0]):
+            # v is a pair, (type, instance)
             v = create_pair(k, v[0], v[1])
             vars.append(k)
         elif isinstance(v, list) and \
                 isinstance(v[0], type):
+            # v is a list [type]
             v = create_pair(k, v[0], container=list)
             vars.append(k)
         elif isinstance(v, tuple) and \
                 isinstance(v[0], list) and \
                 isinstance(v[0][0], type) and \
-                isinstance(v[1], list) and \
-                isinstance(v[1][0], v[0][0]):
-            v = create_pair(k, v[0][0], v[1][0], container=list)
-            vars.append(k)
+                isinstance(v[1], list):
+            # v is a pair,  ([type], [instance?])
+            if len(v[1]) > 0 and isinstance(v[1][0], v[0][0]): # TODO check all
+                v = create_pair(k, v[0][0], v[1], container=list)
+                vars.append(k)
+            elif v[1] == []:
+                v = create_pair(k, v[0][0], v[1], container=list)
+                vars.append(k)
+            else:
+                print(v)
+                raise Exception('Unexpected list instance: %s' % v[1][0])
 
         new_cls_dict[k] = v
+    new_cls_dict['__init__'] = __init__config
     new_cls_dict['__repr__'] = __repr__
     new_cls_dict['_vars'] = vars
     new_cls_dict['_excludes'] = []
     return type(cls)(cls.__name__, cls.__bases__, new_cls_dict)
 
 
-def __init__(self, **kwargs) -> None:
+def __init__config(self, **kwargs) -> None:
+    for item in self._vars:
+        if item not in kwargs:
+            log.debug('WARNING %s unset!', item)
+        else:
+            setattr(self, item, kwargs.get(item))
+    for k, v in kwargs.items():
+        if k not in self._vars:
+            raise Exception('Attribute not found! %s' % k)
+
+
+def __init__struct(self, **kwargs) -> None:
     for item in self._vars:
         if item not in kwargs:
             pass
@@ -132,7 +154,7 @@ def struct(cls):
             # v = create_pair(k, v[0])
 
         new_cls_dict[k] = v
-    new_cls_dict['__init__'] = __init__
+    new_cls_dict['__init__'] = __init__struct
     new_cls_dict['__repr__'] = __repr__
     new_cls_dict['_vars'] = vars
     new_cls_dict['_excludes'] = excludes

algocoin/main.py

@@ -1,10 +1,6 @@
 import tornado
 import threading
-# from .custom_strategies import CustomStrategy
-# from .lib.strategies.sma_crosses_strategy import SMACrossesStrategy
-from .lib.strategies.test_strat import TestStrategy
 from .trading import TradingEngine
-# from .lib.parser import parse_command_line_config, parse_config
 from .lib.parser import parse_command_line_config
 from .lib.logging import LOG as log
 from .ui.server import ServerApplication
@@ -14,33 +10,16 @@ def main(argv: list) -> None:
     config = parse_command_line_config(argv)
 
     port = 8889
-    # config = parse_config(argł)
 
     # Instantiate trading engine
     #
     # The engine is responsible for managing the different components,
     # including the strategies, the bank/risk engine, and the
     # exchange/backtest engine.
+
     te = TradingEngine(config)
     application = ServerApplication(te)
 
-    # A sample strategy that impelements the correct interface
-    # ts = CustomStrategy(50)
-    # ts2 = SMACrossesStrategy(5, 10)
-    ts = TestStrategy()
-    te.registerStrategy(ts)
-    # te.registerStrategy(ts)
-    # te.registerStrategy(ts2)
-
-    # for i in [5, 10, 20, 25, 50, 100]:
-    #     for j in [10, 20, 25, 75, 100, 150, 200]:
-    #         if j > i:
-    #             ts = CustomStrategy(i, j)
-
-    #             # Register the strategy with the Trading engine
-    #             log.critical("registering %d - %d", i, j)
-    #             te.registerStrategy(ts)
-
     log.critical('Server listening on port: %s', port)
     application.listen(port)
     t = threading.Thread(target=tornado.ioloop.IOLoop.current().start)

algocoin/tests/test_config.py

@@ -25,7 +25,8 @@ def teardown_class(cls):
     def test_ExchangeConfig(self):
         x = ExchangeConfig()
         assert(x.exchange_type == ExchangeType.NONE)
-        assert(x.exchange_types == [ExchangeType.NONE])
+        print(x.exchange_types)
+        assert(x.exchange_types == [])
         assert(x.trading_type == TradingType.NONE)
 
     def test_BacktestConfig(self):

algocoin/tests/test_main.py

@@ -43,5 +43,5 @@ def test_parse_command_line(self):
     def test_main(self):
         from ..main import main
         with patch('algocoin.main.TradingEngine'), \
-             patch('algocoin.main.TestStrategy'):
+             patch('algocoin.lib.strategies.test_strat.TestStrategy'):
             main(['', '--live'])

algocoin/tests/test_utils.py

@@ -44,6 +44,7 @@ class Test:
 
         t.c = ['test']
         assert t.c == ['test']
+        print(t.d)
         assert t.d == ['']
 
     def test_struct(self):

algocoin/trading.py

@@ -13,17 +13,25 @@
 
 class TradingEngine(object):
     def __init__(self, options: TradingEngineConfig) -> None:
+        # running live?
         self._live = options.type == TradingType.LIVE
+        # running sandbox?
         self._sandbox = options.type == TradingType.SANDBOX
+        # running backtest?
         self._backtest = options.type == TradingType.BACKTEST
+
+        # running print callback for debug?
         self._print = options.print
 
-        self._strats = []  # type: List[TradingStrategy]
+        # the strategies to run
+        self._strats = []
 
         self._ex = ex_type_to_ex(options.exchange_options.exchange_type)(options.exchange_options) if self._live or self._sandbox else None
         # self._exchanges = [ex_type_to_ex(o.exchange_options.exchange_type)(o.exchange_options) if self._live or self._sandbox else None for o in options]
+
         self._exchanges = []
 
+        # if live or sandbox, get account information and balances
         if self._live or self._sandbox:
             accounts = self._ex.accounts()
 
@@ -36,8 +44,13 @@ def __init__(self, options: TradingEngineConfig) -> None:
             log.info(accounts)
             log.info("Running with %.2f USD" % options.risk_options.total_funds)
 
+        # instantiate backtest engine
         self._bt = Backtest(options.backtest_options) if self._backtest else None
+
+        # instantiate riskengine
         self._rk = Risk(options.risk_options)
+
+        # instantiate execution engine
         self._ec = Execution(options.execution_options, self._ex)
 
         # sanity check
@@ -58,8 +71,15 @@ def __init__(self, options: TradingEngineConfig) -> None:
             if self._backtest:
                 self._bt.registerCallback(Print())
 
-        self._ticked = []  # type: List
+        # register strategies from config
+        for x in options.strategy_options:
+            log.critical('Registering strategy: %s', str(x.clazz))
+            self.registerStrategy(x.clazz(*x.args, **x.kwargs))
+
+        # actively trading or halted?
         self._trading = True  # type: bool
+
+        # pending orders to process (partial fills)
         self._pending = {OrderType.MARKET: [], OrderType.LIMIT: []}  # TODO in progress
 
     def exchange(self):

config/sandbox_gemini.cfg

@@ -8,8 +8,8 @@ exchange=gemini
 
 [strategy]
 strategies = 
-    SMACrossesStrategyWithRegressionFollow, 15, 25
-    SMACrossesStrategy, 15, 25
+    algocoin.lib.strategies.test_strat.TestStrategy,
+    algocoin.lib.strategies.sma_crosses_strategy.SMACrossesStrategy, 15, 25
 
 [risk]
 max_drawdown = 100.0