-from ccxt import ExchangeError, NotSupported
+from ccxt import ExchangeError, NotSupported, RequestTimeout, InvalidNonce
import ccxt_wrapper as ccxt
import time
import psycopg2
from store import *
from cachetools.func import ttl_cache
from datetime import datetime
+import datetime
+from retry import retry
import portfolio
class Market:
trades = None
balances = None
- def __init__(self, ccxt_instance, args,
- user_id=None, market_id=None,
- report_path=None, pg_config=None):
+ def __init__(self, ccxt_instance, args, **kwargs):
self.args = args
self.debug = args.debug
self.ccxt = ccxt_instance
self.balances = BalanceStore(self)
self.processor = Processor(self)
- self.user_id = user_id
- self.market_id = market_id
- self.report_path = report_path
- self.pg_config = pg_config
+ for key in ["user_id", "market_id", "pg_config"]:
+ setattr(self, key, kwargs.get(key, None))
+
+ self.report.log_market(self.args)
@classmethod
- def from_config(cls, config, args,
- user_id=None, market_id=None, report_path=None, pg_config=None):
+ def from_config(cls, config, args, **kwargs):
config["apiKey"] = config.pop("key", None)
ccxt_instance = ccxt.poloniexE(config)
- # For requests logging
- ccxt_instance.session.origin_request = ccxt_instance.session.request
- ccxt_instance.session._parent = ccxt_instance
-
- def request_wrap(self, *args, **kwargs):
- r = self.origin_request(*args, **kwargs)
- self._parent._market.report.log_http_request(args[0],
- args[1], kwargs["data"], kwargs["headers"], r)
- return r
- ccxt_instance.session.request = request_wrap.__get__(ccxt_instance.session,
- ccxt_instance.session.__class__)
-
- return cls(ccxt_instance, args,
- user_id=user_id, market_id=market_id,
- pg_config=pg_config, report_path=report_path)
+ return cls(ccxt_instance, args, **kwargs)
def store_report(self):
self.report.merge(Portfolio.report)
- date = datetime.now()
- if self.report_path is not None:
+ date = datetime.datetime.now()
+ if self.args.report_path is not None:
self.store_file_report(date)
- if self.pg_config is not None:
+ if self.pg_config is not None and self.args.report_db:
self.store_database_report(date)
def store_file_report(self, date):
try:
- report_file = "{}/{}_{}".format(self.report_path, date.isoformat(), self.user_id)
+ report_file = "{}/{}_{}".format(self.args.report_path, date.isoformat(), self.user_id)
with open(report_file + ".json", "w") as f:
f.write(self.report.to_json())
with open(report_file + ".log", "w") as f:
finally:
self.store_report()
+ @retry((RequestTimeout, InvalidNonce), tries=5)
def move_balances(self):
needed_in_margin = {}
moving_to_margin = {}
current_balance = self.balances.all[currency].margin_available
moving_to_margin[currency] = (needed - current_balance)
delta = moving_to_margin[currency].value
+ action = "Moving {} from exchange to margin".format(moving_to_margin[currency])
+
if self.debug and delta != 0:
- self.report.log_debug_action("Moving {} from exchange to margin".format(moving_to_margin[currency]))
+ self.report.log_debug_action(action)
continue
- if delta > 0:
- self.ccxt.transfer_balance(currency, delta, "exchange", "margin")
- elif delta < 0:
- self.ccxt.transfer_balance(currency, -delta, "margin", "exchange")
+ try:
+ if delta > 0:
+ self.ccxt.transfer_balance(currency, delta, "exchange", "margin")
+ elif delta < 0:
+ self.ccxt.transfer_balance(currency, -delta, "margin", "exchange")
+ except (RequestTimeout, InvalidNonce) as e:
+ self.report.log_error(action, message="Retrying", exception=e)
+ self.report.log_move_balances(needed_in_margin, moving_to_margin)
+ self.balances.fetch_balances()
+ raise e
self.report.log_move_balances(needed_in_margin, moving_to_margin)
self.balances.fetch_balances()
self.report.log_stage("follow_orders_tick_{}".format(tick))
self.report.log_orders(open_orders, tick=tick)
for order in open_orders:
- if order.get_status() != "open":
+ status = order.get_status()
+ if status != "open":
self.report.log_order(order, tick, finished=True)
else:
order.trade.update_order(order, tick)
+ if status == "error_disappeared":
+ self.report.log_error("follow_orders",
+ message="{} disappeared, recreating it".format(order))
+ order.trade.prepare_order(
+ compute_value=order.trade.tick_actions_recreate(tick))
+
self.report.log_stage("follow_orders_end")
def prepare_trades(self, base_currency="BTC", liquidity="medium",