onExit 37, cleaned up some interfaces, exchange class makes more sense now

Author: timkpaine

algocoin/execution.py

@@ -24,3 +24,9 @@ def request(self, req: TradeRequest) -> TradeResponse:
         if req.side == Side.BUY:
             return self.requestBuy(req)
         return self.requestSell(req)
+
+    def cancel(self, resp: TradeResponse):  # TODO
+        return self._ex.cancel(resp)
+
+    def cancelAll(self):
+        return self._ex.cancelAll()

algocoin/lib/callback.py

@@ -29,17 +29,21 @@ def onChange(self, data: MarketData):
     def onError(self, data: MarketData):
         '''onError'''
 
-    def onAnalyze(self, data) -> None:
+    def onExit(self):
+        '''onExit'''
+        pass
+
+    def onAnalyze(self, data):
         '''onAnalyze'''
-        raise NotImplemented()
+        pass
 
-    @abstractmethod
     def onHalt(self, data):
         '''onHalt'''
+        pass
 
-    @abstractmethod
     def onContinue(self, data):
         '''onContinue'''
+        pass
 
     def callback(self):
         return self
@@ -67,15 +71,6 @@ def onChange(self, data: MarketData) -> None:
     def onError(self, data: MarketData) -> None:
         pass
 
-    def onAnalyze(self, data: MarketData) -> None:
-        pass
-
-    def onHalt(self, data: MarketData) -> None:
-        pass
-
-    def onContinue(self, data: MarketData) -> None:
-        pass
-
 
 class Print(Callback):
     def __init__(self,

algocoin/lib/data_source.py

@@ -13,17 +13,9 @@ def __init__(self, *args, **kwargs) -> None:
         pass
 
     @abstractmethod
-    def accountInfo(self):
+    def accounts(self):
         '''get account information'''
 
-    @abstractmethod
-    def sendOrder(self, callback: Callback):
-        '''send order to exchange'''
-
-    @abstractmethod
-    def orderResponse(self, response):
-        '''parse the response'''
-
     @abstractmethod
     def buy(self, req: TradeRequest) -> TradeResponse:
         '''execute a buy order'''
@@ -32,6 +24,18 @@ def buy(self, req: TradeRequest) -> TradeResponse:
     def sell(self, req: TradeRequest) -> TradeResponse:
         '''execute a sell order'''
 
+    @abstractmethod
+    def cancel(self, resp: TradeResponse) -> None:
+        '''cancel an order'''
+
+    @abstractmethod
+    def cancelAll(self) -> None:
+        '''cancel all orders'''
+
+    @abstractmethod
+    def orderBook(self):
+        '''return the order book'''
+
 
 class StreamingDataSource(DataSource):
     def __init__(self, *args, **kwargs) -> None:
@@ -91,6 +95,9 @@ def onChange(self, callback: Callback) -> None:
     def onError(self, callback: Callback) -> None:
         self._callbacks[TickType.ERROR].append(callback)
 
+    def onExit(self, callback: Callback) -> None:
+        self._callbacks[TickType.EXIT].append(callback)
+
     def onAnalyze(self, callback: Callback) -> None:
         self._callbacks[TickType.ANALYZE].append(callback)
 

algocoin/lib/enums.py

@@ -17,7 +17,8 @@ class TickType(BaseEnum):
     ANALYZE = 6
     HALT = 7
     CONTINUE = 8
-    HEARTBEAT = 9
+    EXIT = 9
+    HEARTBEAT = 10
 
 
 class TradingType(BaseEnum):

algocoin/lib/exchange.py

@@ -1,12 +1,12 @@
 import json
 from .config import ExchangeConfig
-from .data_source import StreamingDataSource
+from .data_source import StreamingDataSource, RestAPIDataSource
 from .logging import LOG as log
 from .enums import TickType
 from .define import EXCHANGE_MARKET_DATA_ENDPOINT, EXCHANGE_ORDER_ENDPOINT
 
 
-class Exchange(StreamingDataSource):
+class Exchange(StreamingDataSource, RestAPIDataSource):
     def __init__(self, options: ExchangeConfig) -> None:
         super(Exchange, self).__init__(options)
         self._lastseqnum = -1

algocoin/lib/exchanges/gdax.py

@@ -90,26 +90,81 @@ def buy(self, req: TradeRequest) -> TradeResponse:
         '''execute a buy order'''
         params = GDAXExchange.trade_req_to_params(req)
         log.warn("Buy params: %s", str(params))
-        res = self._client.buy(**params)
-        return TradeResponse(request=req,
+        order = self._client.buy(**params)
+        '''{
+            "id": "d0c5340b-6d6c-49d9-b567-48c4bfca13d2",
+            "price": "0.10000000",
+            "size": "0.01000000",
+            "product_id": "BTC-USD",
+            "side": "buy",
+            "stp": "dc",
+            "type": "limit",
+            "time_in_force": "GTC",
+            "post_only": false,
+            "created_at": "2016-12-08T20:02:28.53864Z",
+            "fill_fees": "0.0000000000000000",
+            "filled_size": "0.00000000",
+            "executed_value": "0.0000000000000000",
+            "status": "pending",
+            "settled": false
+        }'''
+
+        # FIXME check these
+        slippage = req.price-float(order['price'])
+        txn_cost = float(order.get('fill_fees'))
+        status = TradeResult.NONE
+
+        if (float(order['filled_size']) - req.volume) < 0.001 or order['status'] == 'done':
+            status = TradeResult.FILLED
+        elif False:  # FIXME
+            status = TradeResult.REJECTED
+        elif float(order.get('filled_size', 0.0)) == req.size:
+            status = TradeResult.PARTIAL
+        else:
+            status = TradeResult.PENDING
+
+        resp = TradeResponse(request=req,
                              side=req.side,
-                             volume=0.0,
-                             price=0.0,
-                             currency=CurrencyType.BTC,
-                             slippage=0.0,
-                             transaction_cost=0.0,
-                             status=TradeResult.FILLED)
+                             volume=float(order['filled_size']),
+                             price=float(order['price']),
+                             currency=req.currency,
+                             slippage=slippage,
+                             transaction_cost=txn_cost,
+                             status=status,
+                             order_id=str(order['order_id']),
+                             remaining=float(order.get('remaining_amount', 0.0)),
+                             )
+        return resp
 
     def sell(self, req: TradeRequest) -> TradeResponse:
         '''execute a sell order'''
         params = GDAXExchange.trade_req_to_params(req)
         log.warn("Sell params: %s", str(params))
-        res = self._client.sell(**params)
-        return TradeResponse(request=req,
+        order = self._client.sell(**params)
+
+        # FIXME check these
+        slippage = req.price-float(order['price'])
+        txn_cost = float(order.get('fill_fees'))
+        status = TradeResult.NONE
+
+        if (float(order['filled_size']) - req.volume) < 0.001 or order['status'] == 'done':
+            status = TradeResult.FILLED
+        elif False:  # FIXME
+            status = TradeResult.REJECTED
+        elif float(order.get('filled_size', 0.0)) == req.size:
+            status = TradeResult.PARTIAL
+        else:
+            status = TradeResult.PENDING
+
+        resp = TradeResponse(request=req,
                              side=req.side,
-                             volume=0.0,
-                             price=0.0,
-                             currency=CurrencyType.BTC,
-                             slippage=0.0,
-                             transaction_cost=0.0,
-                             status=TradeResult.FILLED)
+                             volume=float(order['filled_size']),
+                             price=float(order['price']),
+                             currency=req.currency,
+                             slippage=slippage,
+                             transaction_cost=txn_cost,
+                             status=status,
+                             order_id=str(order['order_id']),
+                             remaining=float(order.get('remaining_amount', 0.0)),
+                             )
+        return resp

algocoin/lib/exchanges/gemini.py

@@ -67,6 +67,7 @@ def run(self, engine) -> None:
 
             except KeyboardInterrupt:
                 log.critical('Terminating program')
+                engine.terminate()
                 return
         return self._accounts
 
@@ -84,7 +85,31 @@ def buy(self, req: TradeRequest) -> TradeResponse:
                                        'buy',
                                        client_order_id=None,
                                        order_execution=None)
+
+        '''{
+            "avg_execution_price": "0.00",
+            "client_order_id": "20170208_example",
+            "exchange": "gemini",
+            "executed_amount": "0",
+            "id": "372456298",
+            "is_cancelled": false,
+            "is_hidden": false,
+            "is_live": true,
+            "order_id": "372456298",
+            "original_amount": "14.0296",
+            "price": "1059.54",
+            "remaining_amount": "14.0296",
+            "side": "buy",
+            "symbol": "btcusd",
+            "timestamp": "1478203017",
+            "timestampms": 1478203017455,
+            "type": "exchange limit",
+            "was_forced": false
+        }'''
         # FIXME check these
+        if order.get('result') == 'error':
+            raise Exception('Order Error!')
+
         slippage = float(params['price'])-float(order['avg_execution_price'])
         txn_cost = 0.0
         status = TradeResult.NONE
@@ -122,8 +147,13 @@ def sell(self, req: TradeRequest) -> TradeResponse:
                                        client_order_id=None,
                                        order_execution=None)
 
+        if order.get('result') == 'error':
+            raise Exception('Order Error!')
+
         # FIXME check these
-        slippage = float(params['price'])-float(order['avg_execution_price'])
+        if 'avg_execution_price' not in order:
+            import pdb; pdb.set_trace()
+        slippage = float(params['price'])-float(order.get('avg_execution_price'))
         txn_cost = 0.0
         status = TradeResult.NONE
 
@@ -176,3 +206,12 @@ def receive(self) -> None:
                     pass
                 else:
                     self.callback(TickType.ERROR, res)
+
+    def cancel(self, resp: TradeResponse):
+        '''cancel an order'''
+        raise NotImplementedError()
+
+    def cancelAll(self) -> None:
+        '''cancel all orders'''
+        log.critical('Cancelling all active orders')
+        self._client.cancel_all_active_orders()

algocoin/lib/order_book.py

@@ -0,0 +1,6 @@
+from abc import ABCMeta
+
+
+class OrderBook(metaclass=ABCMeta):
+    '''OrderBook interface'''
+    pass

algocoin/lib/strategies/test_strat.py

@@ -48,37 +48,35 @@ def onTrade(self, data: MarketData) -> bool:
                                price=data.price)
             slog.critical("requesting buy : %s", req)
             self.requestBuy(self.onBuy, req)
+            self.active = True
             return True
         else:
-            req = TradeRequest(side=Side.SELL,
-                               volume=self.bought_qty,
-                               currency=data.currency,
-                               order_type=OrderType.MARKET,
-                               price=data.price)
-            slog.critical("requesting sell : %s", req)
-            self.requestSell(self.onSell, req)
-            return True
-
+            if self.bought_qty:
+                req = TradeRequest(side=Side.SELL,
+                                   volume=self.bought_qty,
+                                   currency=data.currency,
+                                   order_type=OrderType.MARKET,
+                                   price=data.price)
+                slog.critical("requesting sell : %s", req)
+                self.requestSell(self.onSell, req)
+                self.active = False
+                return True
+            else:
+                slog.critical('None bought yet!')
         return False
 
     def onError(self, e) -> None:
         elog.critical(e)
 
-    def onAnalyze(self, _) -> None:
-        pass
+    def onExit(self) -> None:
+        self.cancelAll(lambda *args: True)
 
     def onChange(self, data: MarketData) -> None:
         pass
 
-    def onContinue(self, data: MarketData) -> None:
-        pass
-
     def onDone(self, data: MarketData) -> None:
         pass
 
-    def onHalt(self, data: MarketData) -> None:
-        pass
-
     def onOpen(self, data: MarketData) -> None:
         pass
 

algocoin/lib/strategy.py

@@ -48,18 +48,22 @@ def registerDesire(self, time, actionType, data) -> None:
 
 
 class TradingStrategy(Strategy, Callback):
-    def requestBuy(self,
-                   callback: Callable,
-                   req: TradeRequest,
-                   callback_failure=None) -> None:
+    def requestBuy(self, callback: Callable, req: TradeRequest, callback_failure=None) -> None:
+        '''attempt to buy'''
         self._te.requestBuy(callback, req, callback_failure, self)
 
-    def requestSell(self,
-                    callback: Callable,
-                    req: TradeRequest,
-                    callback_failure=None) -> None:
+    def requestSell(self, callback: Callable, req: TradeRequest, callback_failure=None) -> None:
+        '''attempt to sell'''
         self._te.requestSell(callback, req, callback_failure, self)
 
+    def cancel(self, callback: Callable, resp: TradeResponse, callback_failure=None) -> None:
+        '''cancel order'''
+        self._te.cancel(callback, resp, callback_failure, self)
+
+    def cancelAll(self, callback: Callable, callback_failure=None):
+        '''cancel all orders'''
+        self._te.cancelAll(callback, callback_failure, self)
+
     def slippage(self, data: TradeResponse) -> TradeResponse:
         '''slippage model. default is pass through'''
         return data