Various fixes/improvementsv0.3

- Use pending gains to compute the move_balance
- Use ttl_cache for tickers

1 files changed, 36 insertions, 33 deletions

diff --git a/market.py b/market.py
index 0cb3e67..9122fc0 100644
--- a/market.py
+++ b/market.py
@@ -1,7 +1,8 @@
-from ccxt import ExchangeError
+from ccxt import ExchangeError, NotSupported
 import ccxt_wrapper as ccxt
 import time
 from store import *
+from cachetools.func import ttl_cache
 
 class Market:
     debug = False
@@ -42,19 +43,17 @@ class Market:
         needed_in_margin = {} 
         moving_to_margin = {}
 
-        for currency in self.balances.all:
-            if self.balances.all[currency].margin_free != 0:
-                needed_in_margin[currency] = 0
-        for trade in self.trades.all:
-            if trade.value_to.currency not in needed_in_margin:
-                needed_in_margin[trade.value_to.currency] = 0
+        for currency, balance in self.balances.all.items():
+            needed_in_margin[currency] = balance.margin_in_position - balance.margin_pending_gain
+        for trade in self.trades.pending:
+            needed_in_margin.setdefault(trade.base_currency, 0)
             if trade.trade_type == "short":
-                needed_in_margin[trade.value_to.currency] += abs(trade.value_to)
+                needed_in_margin[trade.base_currency] -= trade.delta
         for currency, needed in needed_in_margin.items():
-            current_balance = self.balances.all[currency].margin_free
+            current_balance = self.balances.all[currency].margin_available
             moving_to_margin[currency] = (needed - current_balance)
             delta = moving_to_margin[currency].value
-            if self.debug:
+            if self.debug and delta != 0:
                 self.report.log_debug_action("Moving {} from exchange to margin".format(moving_to_margin[currency]))
                 continue
             if delta > 0:
@@ -65,14 +64,18 @@ class Market:
 
         self.balances.fetch_balances()
 
-    fees_cache = {}
+    @ttl_cache(ttl=3600)
     def fetch_fees(self):
-        if self.ccxt.__class__ not in self.fees_cache:
-            self.fees_cache[self.ccxt.__class__] = self.ccxt.fetch_fees()
-        return self.fees_cache[self.ccxt.__class__]
+        return self.ccxt.fetch_fees()
+
+    @ttl_cache(maxsize=20, ttl=5)
+    def get_tickers(self, refresh=False):
+        try:
+            return self.ccxt.fetch_tickers()
+        except NotSupported:
+            return None
 
-    ticker_cache = {}
-    ticker_cache_timestamp = time.time()
+    @ttl_cache(maxsize=20, ttl=5)
     def get_ticker(self, c1, c2, refresh=False):
         def invert(ticker):
             return {
@@ -86,25 +89,25 @@ class Market:
                 "average": (ticker["bid"] + ticker["ask"] ) / 2,
                 })
 
-        if time.time() - self.ticker_cache_timestamp > 5:
-            self.ticker_cache = {}
-            self.ticker_cache_timestamp = time.time()
-        elif not refresh:
-            if (c1, c2, self.ccxt.__class__) in self.ticker_cache:
-                return self.ticker_cache[(c1, c2, self.ccxt.__class__)]
-            if (c2, c1, self.ccxt.__class__) in self.ticker_cache:
-                return invert(self.ticker_cache[(c2, c1, self.ccxt.__class__)])
-
-        try:
-            self.ticker_cache[(c1, c2, self.ccxt.__class__)] = self.ccxt.fetch_ticker("{}/{}".format(c1, c2))
-            augment_ticker(self.ticker_cache[(c1, c2, self.ccxt.__class__)])
-        except ExchangeError:
+        tickers = self.get_tickers()
+        if tickers is None:
             try:
-                self.ticker_cache[(c2, c1, self.ccxt.__class__)] = self.ccxt.fetch_ticker("{}/{}".format(c2, c1))
-                augment_ticker(self.ticker_cache[(c2, c1, self.ccxt.__class__)])
+                ticker = self.ccxt.fetch_ticker("{}/{}".format(c1, c2))
+                augment_ticker(ticker)
             except ExchangeError:
-                self.ticker_cache[(c1, c2, self.ccxt.__class__)] = None
-        return self.get_ticker(c1, c2)
+                try:
+                    ticker = invert(self.ccxt.fetch_ticker("{}/{}".format(c2, c1)))
+                except ExchangeError:
+                    ticker = None
+        else:
+            if "{}/{}".format(c1, c2) in tickers:
+                ticker = tickers["{}/{}".format(c1, c2)]
+                augment_ticker(ticker)
+            elif "{}/{}".format(c2, c1) in tickers:
+                ticker = invert(tickers["{}/{}".format(c2, c1)])
+            else:
+                ticker = None
+        return ticker
 
     def follow_orders(self, sleep=None):
         if sleep is None: