major refactoring

main.py

@@ -7,6 +7,8 @@ import time
 import traceback
 from datetime import datetime
 
+from wrapt import synchronized
+
 logging.basicConfig(level=logging.DEBUG,
                     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -19,44 +21,34 @@ from utils import get_conf
 __author__ = "gcarq"
 __copyright__ = "gcarq 2017"
 __license__ = "custom"
-__version__ = "0.4"
+__version__ = "0.5.1"
 
 
 conf = get_conf()
 api_wrapper = get_exchange_api(conf)
 
-_lock = threading.Condition()
-_instance = None
-_should_stop = False
+
+@synchronized
+def get_instance(recreate=False):
+    """
+    Get the current instance of this thread. This is a singleton.
+    :param recreate: Must be True if you want to start the instance
+    :return: TradeThread instance
+    """
+    global _instance, _should_stop
+    if recreate and not _instance.is_alive():
+        logger.debug('Creating TradeThread instance')
+        _should_stop = False
+        _instance = TradeThread()
+    return _instance
+
+
+def stop_instance():
+    global _should_stop
+    _should_stop = True
 
 
 class TradeThread(threading.Thread):
-    @staticmethod
-    def get_instance(recreate=False):
-        """
-        Get the current instance of this thread. This is a singleton.
-        :param recreate: Must be True if you want to start the instance
-        :return: TradeThread instance
-        """
-        global _instance, _should_stop
-        _lock.acquire()
-        if _instance is None or (not _instance.is_alive() and recreate):
-            _should_stop = False
-            _instance = TradeThread()
-        _lock.release()
-        return _instance
-
-    @staticmethod
-    def stop():
-        """
-        Sets stop signal for the current instance
-        :return: None
-        """
-        global _should_stop
-        _lock.acquire()
-        _should_stop = True
-        _lock.release()
-
     def run(self):
         """
         Threaded main function
@@ -64,25 +56,10 @@ class TradeThread(threading.Thread):
         """
         try:
             TelegramHandler.send_msg('*Status:* `trader started`')
+            logger.info('Trader started')
             while not _should_stop:
                 try:
-                    # Query trades from persistence layer
-                    trade = Trade.query.filter(Trade.is_open.is_(True)).first()
-                    if not trade:
-                        # Create entity and execute trade
-                        Session.add(create_trade(float(conf['stake_amount']), api_wrapper.exchange))
-                        continue
-
-                    # Check if there is already an open order for this pair
-                    orders = api_wrapper.get_open_orders(trade.pair)
-                    if orders:
-                        msg = 'There is already an open order for this trade. (total: {}, remaining: {}, type: {})'\
-                            .format(round(orders[0]['amount'], 8), round(orders[0]['remaining'], 8), orders[0]['type'])
-                        logger.info(msg)
-                    elif close_trade_if_fulfilled(trade):
-                        logger.info('No open orders found and close values are set. Marking trade as closed ...')
-                    else:
-                        handle_trade(trade)
+                    self._process()
                 except ValueError:
                     logger.exception('ValueError')
                 finally:
@@ -92,9 +69,47 @@ class TradeThread(threading.Thread):
             TelegramHandler.send_msg('*Status:* Got RuntimeError: ```\n{}\n```'.format(traceback.format_exc()))
             logger.exception('RuntimeError. Stopping trader ...')
         finally:
-            Session.flush()
             TelegramHandler.send_msg('*Status:* `Trader has stopped`')
 
+    @staticmethod
+    def _process():
+        """
+        Queries the persistence layer for new trades and handles them
+        :return: None
+        """
+        # Query trades from persistence layer
+        trade = Trade.query.filter(Trade.is_open.is_(True)).first()
+        if not trade:
+            # Create entity and execute trade
+            Session.add(create_trade(float(conf['stake_amount']), api_wrapper.exchange))
+            return
+
+        # Check if there is already an open order for this trade
+        orders = api_wrapper.get_open_orders(trade.pair)
+        orders = [o for o in orders if o['id'] == trade.open_order_id]
+        if orders:
+            msg = 'There exists an open order for this trade: (total: {}, remaining: {}, type: {}, id: {})' \
+                .format(round(orders[0]['amount'], 8),
+                        round(orders[0]['remaining'], 8),
+                        orders[0]['type'],
+                        orders[0]['id'])
+            logger.info(msg)
+            return
+
+        # Update state
+        trade.open_order_id = None
+        # Check if this trade can be marked as closed
+        if close_trade_if_fulfilled(trade):
+            logger.info('No open orders found and trade is fulfilled. Marking as closed ...')
+            return
+
+        # Check if we can sell our current pair
+        handle_trade(trade)
+
+# Initial stopped TradeThread instance
+_instance = TradeThread()
+_should_stop = False
+
 
 def close_trade_if_fulfilled(trade):
     """
@@ -104,7 +119,7 @@ def close_trade_if_fulfilled(trade):
     """
     # If we don't have an open order and the close rate is already set,
     # we can close this trade.
-    if trade.close_profit and trade.close_date and trade.close_rate:
+    if trade.close_profit and trade.close_date and trade.close_rate and not trade.open_order_id:
         trade.is_open = False
         return True
     return False
@@ -112,9 +127,8 @@ def close_trade_if_fulfilled(trade):
 
 def handle_trade(trade):
     """
-    Sells the current pair if the threshold is reached
-    and updates the trade record.
-    :return: current instance
+    Sells the current pair if the threshold is reached and updates the trade record.
+    :return: None
     """
     try:
         if not trade.is_open:
@@ -122,7 +136,7 @@ def handle_trade(trade):
 
         logger.debug('Handling open trade {} ...'.format(trade))
         # Get current rate
-        current_rate = api_wrapper.get_ticker(trade.pair)['last']
+        current_rate = api_wrapper.get_ticker(trade.pair)['bid']
         current_profit = 100 * ((current_rate - trade.open_rate) / trade.open_rate)
 
         # Get available balance
@@ -136,10 +150,11 @@ def handle_trade(trade):
             if time_diff > duration and current_rate > (1 + threshold) * trade.open_rate:
 
                 # Execute sell and update trade record
-                api_wrapper.sell(trade.pair, current_rate, balance)
+                order_id = api_wrapper.sell(trade.pair, current_rate, balance)
                 trade.close_rate = current_rate
                 trade.close_profit = current_profit
                 trade.close_date = datetime.utcnow()
+                trade.open_order_id = order_id
 
                 message = '*{}:* Selling {} at rate `{:f} (profit: {}%)`'.format(
                     trade.exchange.name,
@@ -168,40 +183,35 @@ def create_trade(stake_amount: float, exchange):
         raise ValueError('BTC amount is not fulfilled')
 
     # Remove latest trade pair from whitelist
-    latest_trade = Trade.order_by(Trade.id.desc()).first()
+    latest_trade = Trade.query.order_by(Trade.id.desc()).first()
     if latest_trade and latest_trade.pair in whitelist:
         whitelist.remove(latest_trade.pair)
-        logger.debug('Ignoring {} in pair whitelist')
+        logger.debug('Ignoring {} in pair whitelist'.format(latest_trade.pair))
     if not whitelist:
         raise ValueError('No pair in whitelist')
 
     # Pick random pair and execute trade
     idx = random.randint(0, len(whitelist) - 1)
     pair = whitelist[idx]
-    open_rate = api_wrapper.get_ticker(pair)['last']
+    open_rate = api_wrapper.get_ticker(pair)['ask']
     amount = stake_amount / open_rate
     exchange = exchange
-    api_wrapper.buy(pair, open_rate, amount)
+    order_id = api_wrapper.buy(pair, open_rate, amount)
 
-    trade = Trade(
-        pair=pair,
-        btc_amount=stake_amount,
-        open_rate=open_rate,
-        amount=amount,
-        exchange=exchange,
-    )
-    message = '*{}:* Buying {} at rate `{:f}`'.format(
-        trade.exchange.name,
-        trade.pair.replace('_', '/'),
-        trade.open_rate
-    )
+    # Create trade entity and return
+    message = '*{}:* Buying {} at rate `{:f}`'.format(exchange.name, pair.replace('_', '/'), open_rate)
     logger.info(message)
     TelegramHandler.send_msg(message)
-    return trade
+    return Trade(pair=pair,
+                 btc_amount=stake_amount,
+                 open_rate=open_rate,
+                 amount=amount,
+                 exchange=exchange,
+                 open_order_id=order_id)
 
 
 if __name__ == '__main__':
     logger.info('Starting marginbot {}'.format(__version__))
     TelegramHandler.listen()
     while True:
-        time.sleep(0.1)
+        time.sleep(0.5)