Exchange type to c++

AsyncAlgoTrading · Jun 7, 2019 · e46b2b5 · e46b2b5
1 parent 0b93f86
commit e46b2b5
Show file tree

Hide file tree

Showing 10 changed files with 98 additions and 133 deletions.
diff --git a/aat/backtest.py b/aat/backtest.py
@@ -3,7 +3,7 @@
 from .data_source import StreamingDataSource
 from .logging import LOG as log, DATA as dlog
 from .structs import MarketData, Instrument
-from .enums import PairType, TickType, ExchangeType, Side
+from .enums import PairType, TickType, ExchangeType_from_string, Side
 
 
 def line_to_data(record):
@@ -12,7 +12,7 @@ def line_to_data(record):
                       price=record.close,
                       type=TickType.TRADE,
                       instrument=Instrument(underlying=PairType.from_string(record.name[1])),
-                      exchange=ExchangeType(record.exchange),
+                      exchange=ExchangeType_from_string(record.exchange),
                       side=Side.NONE)
     return data
 

diff --git a/aat/define.py b/aat/define.py
@@ -3,13 +3,6 @@
 
 
 EXCHANGE_MARKET_DATA_ENDPOINT = lru_cache(None)(lambda name, typ: {  # noqa: E731
-    (ExchangeType.BITSTAMP, TradingType.SANDBOX): '',
-    (ExchangeType.BITSTAMP, TradingType.SIMULATION): 'wss://ws.bitstamp.net',
-    (ExchangeType.BITSTAMP, TradingType.LIVE): 'wss://ws.bitstamp.net',
-
-    (ExchangeType.BITFINEX, TradingType.SANDBOX): '',
-    (ExchangeType.BITFINEX, TradingType.LIVE): '',
-
     (ExchangeType.COINBASE, TradingType.SANDBOX): 'wss://ws-feed-public.sandbox.pro.coinbase.com',
     (ExchangeType.COINBASE, TradingType.LIVE): 'wss://ws-feed.pro.coinbase.com',
     (ExchangeType.COINBASE, TradingType.SIMULATION): 'wss://ws-feed.pro.coinbase.com',
@@ -26,23 +19,13 @@
     (ExchangeType.POLONIEX, TradingType.LIVE): 'wss://api2.poloniex.com',
     (ExchangeType.POLONIEX, TradingType.SIMULATION): 'wss://api2.poloniex.com',
 
-    (ExchangeType.DERIBIT, TradingType.SANDBOX): 'wss://test.deribit.com/ws/api/v1/',
-    (ExchangeType.DERIBIT, TradingType.LIVE): 'wss://www.deribit.com/ws/api/v1/',
-    (ExchangeType.DERIBIT, TradingType.SIMULATION): 'wss://www.deribit.com/ws/api/v1/',
+    # (ExchangeType.DERIBIT, TradingType.SANDBOX): 'wss://test.deribit.com/ws/api/v1/',
+    # (ExchangeType.DERIBIT, TradingType.LIVE): 'wss://www.deribit.com/ws/api/v1/',
+    # (ExchangeType.DERIBIT, TradingType.SIMULATION): 'wss://www.deribit.com/ws/api/v1/',
 
 }.get((name, typ), None))
 
 EXCHANGE_ORDER_ENDPOINT = lru_cache(None)(lambda name, typ: {  # noqa: E731
-    (ExchangeType.BITSTAMP, TradingType.SANDBOX): '',
-    (ExchangeType.BITSTAMP, TradingType.LIVE): '',
-
-    (ExchangeType.BITFINEX, TradingType.SANDBOX): '',
-    (ExchangeType.BITFINEX, TradingType.LIVE): '',
-
-    (ExchangeType.GDAX, TradingType.SANDBOX): 'https://api-public.sandbox.gdax.com',
-    (ExchangeType.GDAX, TradingType.LIVE): 'https://api.gdax.com',
-    (ExchangeType.GDAX, TradingType.SIMULATION): 'https://api.gdax.com',
-
     (ExchangeType.COINBASE, TradingType.SANDBOX): 'https://api-public.sandbox.pro.coinbase.com',
     (ExchangeType.COINBASE, TradingType.LIVE): 'https://api.pro.coinbase.com',
     (ExchangeType.COINBASE, TradingType.SIMULATION): 'https://api.pro.coinbase.com',
@@ -57,35 +40,13 @@
     (ExchangeType.POLONIEX, TradingType.SANDBOX): '',
     (ExchangeType.POLONIEX, TradingType.LIVE): '',
 
-    (ExchangeType.DERIBIT, TradingType.SANDBOX): 'https://test.deribit.com',
-    (ExchangeType.DERIBIT, TradingType.LIVE): 'https://www.deribit.com',
-    (ExchangeType.DERIBIT, TradingType.SIMULATION): 'https://www.deribit.com',
-
+    # (ExchangeType.DERIBIT, TradingType.SANDBOX): 'https://test.deribit.com',
+    # (ExchangeType.DERIBIT, TradingType.LIVE): 'https://www.deribit.com',
+    # (ExchangeType.DERIBIT, TradingType.SIMULATION): 'https://www.deribit.com',
 }.get((name, typ), None))
 
 ACCOUNTS = lambda name, typ: {  # noqa: E731
-    (ExchangeType.BITSTAMP, TradingType.SANDBOX): '',
-    (ExchangeType.BITSTAMP, TradingType.LIVE): '',
-
-    (ExchangeType.BITFINEX, TradingType.SANDBOX): '',
-    (ExchangeType.BITFINEX, TradingType.LIVE): '',
-
-    (ExchangeType.GDAX, TradingType.SANDBOX): 'https://api-public.sandbox.gdax.com',
-    (ExchangeType.GDAX, TradingType.LIVE): 'https://api.gdax.com',
-    (ExchangeType.GDAX, TradingType.SIMULATION): 'https://api.gdax.com',
-
-    (ExchangeType.GEMINI, TradingType.SANDBOX): 'https://api.sandbox.gemini.com',
-    (ExchangeType.GEMINI, TradingType.LIVE): 'https://api.gemini.com',
-    (ExchangeType.GEMINI, TradingType.SIMULATION): 'https://api.gemini.com',
-
-    (ExchangeType.KRAKEN, TradingType.SANDBOX): '',
-    (ExchangeType.KRAKEN, TradingType.LIVE): '',
-
-    (ExchangeType.POLONIEX, TradingType.SANDBOX): '',
-    (ExchangeType.POLONIEX, TradingType.LIVE): '',
-
-    (ExchangeType.DERIBIT, TradingType.SANDBOX): 'https://test.deribit.com',
-    (ExchangeType.DERIBIT, TradingType.LIVE): 'https://www.deribit.com',
-    (ExchangeType.DERIBIT, TradingType.SIMULATION): 'https://www.deribit.com',
-
+    # (ExchangeType.DERIBIT, TradingType.SANDBOX): 'https://test.deribit.com',
+    # (ExchangeType.DERIBIT, TradingType.LIVE): 'https://www.deribit.com',
+    # (ExchangeType.DERIBIT, TradingType.SIMULATION): 'https://www.deribit.com',
 }.get((name, typ), None)
diff --git a/aat/enums.py b/aat/enums.py
@@ -1,6 +1,15 @@
 from functools import lru_cache
 from enum import Enum
-from ._enums import TickType, to_string as TickType_to_string, from_string as TickType_from_string  # noqa: F401
+from ._enums import (  # noqa: F401
+    TickType,
+    TickTypes,
+    TickType_to_string,
+    TickType_from_string,
+    ExchangeType,
+    ExchangeTypes,
+    ExchangeType_to_string,
+    ExchangeType_from_string,
+    )
 
 
 class BaseEnum(Enum):
@@ -17,22 +26,6 @@ class TradingType(BaseEnum):
     SIMULATION = 'SIMULATION'
 
 
-class ExchangeType(BaseEnum):
-    NONE = 'NONE'
-    BITSTAMP = 'BITSTAMP'
-    BITFINEX = 'BITFINEX'
-    CEX = 'CEX'
-    COINBASE = 'COINBASE'
-    GEMINI = 'GEMINI'
-    HITBTC = 'HITBTC'
-    ITBIT = 'ITBIT'
-    KRAKEN = 'KRAKEN'
-    LAKE = 'LAKE'
-    POLONIEX = 'POLONIEX'
-    DERIBIT = 'DERIBIT'
-    BITMEX = 'BITMEX'
-
-
 class CurrencyType(BaseEnum):
     NONE = 'NONE'  # special, dont use
 

diff --git a/aat/structs.py b/aat/structs.py
@@ -3,6 +3,7 @@
 from enum import Enum
 from .enums import Side, \
                    ExchangeType, \
+                   ExchangeType_to_string, \
                    OptionSide, \
                    CurrencyType, \
                    PairType, \
@@ -32,6 +33,8 @@ def to_dict(self, serializable=False, str_timestamp=False, **kwargs) -> dict:
                     ret[item] = str(getattr(self, item))
                 elif isinstance(ret[item], TickType):
                     ret[item] = TickType_to_string(ret[item])
+                elif isinstance(ret[item], ExchangeType):
+                    ret[item] = ExchangeType_to_string(ret[item])
                 elif isinstance(ret[item], float):
                     if ((ret[item] >= float('inf')) is False) and \
                        ((ret[item] <= float('inf')) is False):

diff --git a/aat/tests/test_define.py b/aat/tests/test_define.py
@@ -21,14 +21,6 @@ def test_exchange_endpoint(self):
         from ..define import EXCHANGE_MARKET_DATA_ENDPOINT
         from ..enums import ExchangeType, TradingType
 
-        assert EXCHANGE_MARKET_DATA_ENDPOINT(ExchangeType.BITSTAMP, TradingType.SANDBOX) \
-            == ''
-        assert EXCHANGE_MARKET_DATA_ENDPOINT(ExchangeType.BITSTAMP, TradingType.LIVE) \
-            == 'wss://ws.bitstamp.net'
-        assert EXCHANGE_MARKET_DATA_ENDPOINT(ExchangeType.BITFINEX, TradingType.SANDBOX) \
-            == ''
-        assert EXCHANGE_MARKET_DATA_ENDPOINT(ExchangeType.BITFINEX, TradingType.LIVE) \
-            == ''
         assert EXCHANGE_MARKET_DATA_ENDPOINT(ExchangeType.COINBASE, TradingType.SANDBOX) \
             == 'wss://ws-feed-public.sandbox.pro.coinbase.com'
         assert EXCHANGE_MARKET_DATA_ENDPOINT(ExchangeType.COINBASE, TradingType.LIVE) \

diff --git a/aat/tests/test_enums.py b/aat/tests/test_enums.py
@@ -33,43 +33,22 @@ def test_trading_type(self):
         assert t3 == TradingType('BACKTEST')
 
     def test_exchange_type(self):
-        from ..enums import ExchangeType
+        from ..enums import ExchangeType, ExchangeType_from_string
         t0 = ExchangeType.NONE
-        t1 = ExchangeType.BITSTAMP
-        t2 = ExchangeType.BITFINEX
-        t3 = ExchangeType.CEX
-        t4 = ExchangeType.COINBASE
-        t5 = ExchangeType.GEMINI
-        t6 = ExchangeType.HITBTC
-        t7 = ExchangeType.ITBIT
-        t8 = ExchangeType.KRAKEN
-        t9 = ExchangeType.LAKE
-        t10 = ExchangeType.POLONIEX
-        t11 = ExchangeType.COINBASE
+        t1 = ExchangeType.COINBASE
+        t2 = ExchangeType.GEMINI
+        t3 = ExchangeType.KRAKEN
+        t4 = ExchangeType.POLONIEX
         assert t0 == ExchangeType.NONE
-        assert t1 == ExchangeType.BITSTAMP
-        assert t2 == ExchangeType.BITFINEX
-        assert t3 == ExchangeType.CEX
-        assert t4 == ExchangeType.COINBASE
-        assert t5 == ExchangeType.GEMINI
-        assert t6 == ExchangeType.HITBTC
-        assert t7 == ExchangeType.ITBIT
-        assert t8 == ExchangeType.KRAKEN
-        assert t9 == ExchangeType.LAKE
-        assert t10 == ExchangeType.POLONIEX
-        assert t11 == ExchangeType.COINBASE
-        assert t0 == ExchangeType('NONE')
-        assert t1 == ExchangeType('BITSTAMP')
-        assert t2 == ExchangeType('BITFINEX')
-        assert t3 == ExchangeType('CEX')
-        assert t4 == ExchangeType('COINBASE')
-        assert t5 == ExchangeType('GEMINI')
-        assert t6 == ExchangeType('HITBTC')
-        assert t7 == ExchangeType('ITBIT')
-        assert t8 == ExchangeType('KRAKEN')
-        assert t9 == ExchangeType('LAKE')
-        assert t10 == ExchangeType('POLONIEX')
-        assert t11 == ExchangeType('COINBASE')
+        assert t1 == ExchangeType.COINBASE
+        assert t2 == ExchangeType.GEMINI
+        assert t3 == ExchangeType.KRAKEN
+        assert t4 == ExchangeType.POLONIEX
+        assert t0 == ExchangeType_from_string('NONE')
+        assert t1 == ExchangeType_from_string('COINBASE')
+        assert t2 == ExchangeType_from_string('GEMINI')
+        assert t3 == ExchangeType_from_string('KRAKEN')
+        assert t4 == ExchangeType_from_string('POLONIEX')
 
     def test_currency_type(self):
         from ..enums import CurrencyType

diff --git a/aat/tests/test_utils.py b/aat/tests/test_utils.py
@@ -81,14 +81,10 @@ def test_str_to_order_type(self):
     def test_str_to_exchange(self):
         from ..utils import str_to_exchange
         from ..enums import ExchangeType
-        assert(str_to_exchange('bitfinex') == ExchangeType.BITFINEX)
-        assert(str_to_exchange('bitstamp') == ExchangeType.BITSTAMP)
+        assert(str_to_exchange('coinbase') == ExchangeType.COINBASE)
         assert(str_to_exchange('gemini') == ExchangeType.GEMINI)
-        assert(str_to_exchange('hitbtc') == ExchangeType.HITBTC)
-        assert(str_to_exchange('itbit') == ExchangeType.ITBIT)
         assert(str_to_exchange('kraken') == ExchangeType.KRAKEN)
-        assert(str_to_exchange('lake') == ExchangeType.LAKE)
-        assert(str_to_exchange('coinbase') == ExchangeType.COINBASE)
+        assert(str_to_exchange('poloniex') == ExchangeType.POLONIEX)
 
     def test_str_to_currency_pair_type(self):
         from ..utils import str_to_currency_pair_type

diff --git a/aat/utils.py b/aat/utils.py
@@ -4,7 +4,7 @@
 import pytz
 from datetime import datetime
 from functools import lru_cache
-from .enums import ExchangeType, CurrencyType, OrderType, Side, PairType
+from .enums import ExchangeType, ExchangeType_from_string, ExchangeTypes, CurrencyType, OrderType, Side, PairType
 from .exceptions import AATException
 from .logging import LOG as log, \
                      STRAT as slog, \
@@ -90,9 +90,9 @@ def str_to_order_type(s: str) -> OrderType:
 
 @lru_cache(None)
 def str_to_exchange(exchange: str) -> ExchangeType:
-    if exchange.upper() not in ExchangeType.members():
+    if exchange.upper() not in ExchangeTypes:
         raise AATException(f'Exchange not recognized: {exchange}')
-    return ExchangeType(exchange.upper())
+    return ExchangeType_from_string(exchange.upper())
 
 
 def set_verbose(level):

diff --git a/cpp/include/aat/common.h b/cpp/include/aat/common.h
@@ -1,3 +1,4 @@
 #pragma once
 
-#define ENUMVAL(name, val) .value(#val , name::val)
+#define ENUM_TO_STRING(type) std::string type##_to_string(type typ) { return type##_names[static_cast<int>(typ)]; }
+#define ENUM_FROM_STRING(type) type type##_from_string(char *s) { return _##type##_mapping[s]; }
diff --git a/cpp/include/aat/enums.hpp b/cpp/include/aat/enums.hpp
@@ -2,10 +2,13 @@
 
 #include <iostream>
 #include <unordered_map>
+#include <vector>
 #include <pybind11/pybind11.h>
+#include <pybind11/stl_bind.h>
 #include "common.h"
 
 namespace py = pybind11;
+PYBIND11_MAKE_OPAQUE(std::vector<std::string>);
 
 namespace aat {
 namespace enums {
@@ -24,7 +27,7 @@ namespace enums {
         HEARTBEAT = 10
     };
 
-    static const char *TickTypeNames[] = {
+    static const std::vector<std::string> TickType_names = {
         "TRADE",
         "OPEN",
         "FILL",
@@ -38,12 +41,7 @@ namespace enums {
         "HEARTBEAT",
     };
 
-    const char *to_string(TickType type)
-    {
-      return TickTypeNames[static_cast<int>(type)];
-    }
-
-    static std::unordered_map<std::string, TickType> _mapping = {
+    static std::unordered_map<std::string, TickType> _TickType_mapping = {
             {"TRADE", TickType::TRADE},
             {"OPEN", TickType::OPEN},
             {"FILL", TickType::FILL},
@@ -57,14 +55,42 @@ namespace enums {
             {"HEARTBEAT", TickType::HEARTBEAT},
     };
 
-    TickType from_string(char *s)
-    { 
-        return _mapping[s];
-    }
+    ENUM_TO_STRING(TickType)
+    ENUM_FROM_STRING(TickType)
+
+    enum class ExchangeType {
+        NONE = 0,
+        COINBASE = 1,
+        GEMINI = 2,
+        KRAKEN = 3,
+        POLONIEX = 4
+    };
+
+    static const std::vector<std::string> ExchangeType_names = {
+        "NONE",
+        "COINBASE",
+        "GEMINI",
+        "KRAKEN",
+        "POLONIEX"
+    };
+
+    static std::unordered_map<std::string, ExchangeType> _ExchangeType_mapping = {
+        {"NONE", ExchangeType::NONE},
+        {"COINBASE", ExchangeType::COINBASE},
+        {"GEMINI", ExchangeType::GEMINI},
+        {"KRAKEN", ExchangeType::KRAKEN},
+        {"POLONIEX", ExchangeType::POLONIEX},
+    };
+
+
+    ENUM_TO_STRING(ExchangeType)
+    ENUM_FROM_STRING(ExchangeType)
+
 }
 }
 
 
+
 PYBIND11_MODULE(_enums, m)
 {
     m.doc() = "C++ enums";
@@ -82,7 +108,21 @@ PYBIND11_MODULE(_enums, m)
         .value("EXIT", TickType::EXIT)
         .value("HEARTBEAT", TickType::HEARTBEAT);
 
-    m.def("to_string", &to_string, "TickType enum to string");
-    m.def("from_string", &from_string, "string to TickType enum");
+    py::bind_vector<std::vector<std::string>>(m, "StringVec");
+    m.attr("TickTypes") = TickType_names;
+
+    m.def("TickType_to_string", &TickType_to_string, "TickType enum to string");
+    m.def("TickType_from_string", &TickType_from_string, "string to TickType enum");
+
+    py::enum_<ExchangeType>(m, "ExchangeType", py::arithmetic())
+        .value("NONE", ExchangeType::NONE)
+        .value("COINBASE", ExchangeType::COINBASE)
+        .value("GEMINI", ExchangeType::GEMINI)
+        .value("KRAKEN", ExchangeType::KRAKEN)
+        .value("POLONIEX", ExchangeType::POLONIEX);
+
+    m.attr("ExchangeTypes") = ExchangeType_names;
+    m.def("ExchangeType_to_string", &ExchangeType_to_string, "ExchangeType enum to string");
+    m.def("ExchangeType_from_string", &ExchangeType_from_string, "string to ExchangeType enum");
 
 }