X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=portfolio.py;h=ed50b570ea2c31d310c6a3d271f37f7f413c43c0;hb=d8deb0e9a6b7b2805e61dc19a287d5474c271cc5;hp=6763fc67a6b56d759deb972cbd75795a424057ce;hpb=f70bb858007cd3be6766ee0aa4a3d9133952eb98;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FCryptoportfolio%2FTrader.git diff --git a/portfolio.py b/portfolio.py index 6763fc6..ed50b57 100644 --- a/portfolio.py +++ b/portfolio.py @@ -3,7 +3,7 @@ from datetime import datetime, timedelta from decimal import Decimal as D, ROUND_DOWN from json import JSONDecodeError from simplejson.errors import JSONDecodeError as SimpleJSONDecodeError -from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder +from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder, OrderNotCached, OrderNotFound from retry import retry import requests @@ -226,8 +226,8 @@ class Amount: class Balance: base_keys = ["total", "exchange_total", "exchange_used", - "exchange_free", "margin_total", "margin_borrowed", - "margin_free"] + "exchange_free", "margin_total", "margin_in_position", + "margin_available", "margin_borrowed", "margin_pending_gain"] def __init__(self, currency, hash_): self.currency = currency @@ -240,8 +240,8 @@ class Balance: base_currency = hash_["margin_borrowed_base_currency"] for key in [ "margin_liquidation_price", - "margin_pending_gain", "margin_lending_fees", + "margin_pending_base_gain", "margin_borrowed_base_price" ]: setattr(self, key, Amount(base_currency, hash_.get(key, 0))) @@ -261,12 +261,12 @@ class Balance: exchange = "" if self.margin_total > 0: - if self.margin_free != 0 and self.margin_borrowed != 0: - margin = " Margin: [✔{} + borrowed {} = {}]".format(str(self.margin_free), str(self.margin_borrowed), str(self.margin_total)) - elif self.margin_free != 0: - margin = " Margin: [✔{}]".format(str(self.margin_free)) + if self.margin_available != 0 and self.margin_in_position != 0: + margin = " Margin: [✔{} + ❌{} = {}]".format(str(self.margin_available), str(self.margin_in_position), str(self.margin_total)) + elif self.margin_available != 0: + margin = " Margin: [✔{}]".format(str(self.margin_available)) else: - margin = " Margin: [borrowed {}]".format(str(self.margin_borrowed)) + margin = " Margin: [❌{}]".format(str(self.margin_in_position)) elif self.margin_total < 0: margin = " Margin: [{} @@ {}/{}]".format(str(self.margin_total), str(self.margin_borrowed_base_price), @@ -290,6 +290,9 @@ class Trade: self.value_to = value_to self.orders = [] self.market = market + self.closed = False + self.inverted = None + assert self.value_from.value * self.value_to.value >= 0 assert self.value_from.currency == self.value_to.currency if self.value_from != 0: assert self.value_from.linked_to is not None and self.value_from.linked_to.currency == self.currency @@ -297,6 +300,10 @@ class Trade: self.value_from.linked_to = Amount(self.currency, 0) self.base_currency = self.value_from.currency + @property + def delta(self): + return self.value_to - self.value_from + @property def action(self): if self.value_from == self.value_to: @@ -309,8 +316,8 @@ class Trade: else: return "dispose" - def order_action(self, inverted): - if (self.value_from < self.value_to) != inverted: + def order_action(self): + if (self.value_from < self.value_to) != self.inverted: return "buy" else: return "sell" @@ -322,6 +329,19 @@ class Trade: else: return "long" + @property + def pending(self): + return not (self.is_fullfiled or self.closed) + + def close(self): + for order in self.orders: + order.cancel() + self.closed = True + + @property + def is_fullfiled(self): + return abs(self.filled_amount(in_base_currency=(not self.inverted))) >= abs(self.delta) + def filled_amount(self, in_base_currency=False): filled_amount = 0 for order in self.orders: @@ -329,53 +349,54 @@ class Trade: return filled_amount def update_order(self, order, tick): - new_order = None - if tick in [0, 1, 3, 4, 6]: + actions = { + 0: ["waiting", None], + 1: ["waiting", None], + 2: ["adjusting", lambda x, y: (x[y] + x["average"]) / 2], + 3: ["waiting", None], + 4: ["waiting", None], + 5: ["adjusting", lambda x, y: (x[y]*2 + x["average"]) / 3], + 6: ["waiting", None], + 7: ["market_fallback", "default"], + } + + if tick in actions: + update, compute_value = actions[tick] + elif tick % 3 == 1: + update = "market_adjust" + compute_value = "default" + else: update = "waiting" compute_value = None - elif tick == 2: - update = "adjusting" - compute_value = 'lambda x, y: (x[y] + x["average"]) / 2' - new_order = self.prepare_order(compute_value=lambda x, y: (x[y] + x["average"]) / 2) - elif tick ==5: - update = "adjusting" - compute_value = 'lambda x, y: (x[y]*2 + x["average"]) / 3' - new_order = self.prepare_order(compute_value=lambda x, y: (x[y]*2 + x["average"]) / 3) - elif tick >= 7: - if (tick - 7) % 3 == 0: - new_order = self.prepare_order(compute_value="default") - update = "market_adjust" - compute_value = "default" - else: - update = "waiting" - compute_value = None - if tick == 7: - update = "market_fallback" + + if compute_value is not None: + order.cancel() + new_order = self.prepare_order(compute_value=compute_value) + else: + new_order = None self.market.report.log_order(order, tick, update=update, compute_value=compute_value, new_order=new_order) if new_order is not None: - order.cancel() new_order.run() self.market.report.log_order(order, tick, new_order=new_order) - def prepare_order(self, compute_value="default"): + def prepare_order(self, close_if_possible=None, compute_value="default"): if self.action is None: return None ticker = self.market.get_ticker(self.currency, self.base_currency) - inverted = ticker["inverted"] - if inverted: + self.inverted = ticker["inverted"] + if self.inverted: ticker = ticker["original"] - rate = Computation.compute_value(ticker, self.order_action(inverted), compute_value=compute_value) + rate = Computation.compute_value(ticker, self.order_action(), compute_value=compute_value) - #TODO: store when the order is considered filled # FIXME: Dust amount should be removed from there if they werent # honored in other sales - delta_in_base = abs(self.value_from - self.value_to) + delta_in_base = abs(self.delta) # 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case) - if not inverted: + if not self.inverted: base_currency = self.base_currency # BTC if self.action == "dispose": @@ -426,13 +447,14 @@ class Trade: delta = delta - filled # I already sold 4 BTC, only 5 left - close_if_possible = (self.value_to == 0) + if close_if_possible is None: + close_if_possible = (self.value_to == 0) if delta <= 0: self.market.report.log_error("prepare_order", message="Less to do than already filled: {}".format(delta)) return None - order = Order(self.order_action(inverted), + order = Order(self.order_action(), delta, rate, base_currency, self.trade_type, self.market, self, close_if_possible=close_if_possible) self.orders.append(order) @@ -448,11 +470,19 @@ class Trade: } def __repr__(self): - return "Trade({} -> {} in {}, {})".format( + if self.closed and not self.is_fullfiled: + closed = " ❌" + elif self.is_fullfiled: + closed = " ✔" + else: + closed = "" + + return "Trade({} -> {} in {}, {}{})".format( self.value_from, self.value_to, self.currency, - self.action) + self.action, + closed) def print_with_order(self, ind=""): self.market.report.print_log("{}{}".format(ind, self)) @@ -476,7 +506,6 @@ class Order: self.trade = trade self.close_if_possible = close_if_possible self.id = None - self.fetch_cache_timestamp = None self.tries = 0 def as_json(self): @@ -521,7 +550,7 @@ class Order: @property def finished(self): - return self.status == "closed" or self.status == "canceled" or self.status == "error" + return self.status.startswith("closed") or self.status == "canceled" or self.status == "error" @retry(InsufficientFunds) def run(self): @@ -565,43 +594,38 @@ class Order: # other states are "closed" and "canceled" if not self.finished: self.fetch() - if self.finished: - self.mark_finished_order() return self.status def mark_finished_order(self): - if self.market.debug: + if self.status.startswith("closed") and self.market.debug: self.market.report.log_debug_action("Mark {} as finished".format(self)) return - if self.status == "closed": + if self.status.startswith("closed"): if self.trade_type == "short" and self.action == "buy" and self.close_if_possible: self.market.ccxt.close_margin_position(self.amount.currency, self.base_currency) - def fetch(self, force=False): + def fetch(self): if self.market.debug: self.market.report.log_debug_action("Fetching {}".format(self)) return - if (not force and self.fetch_cache_timestamp is not None - and time.time() - self.fetch_cache_timestamp < 10): - return - self.fetch_cache_timestamp = time.time() - - result = self.market.ccxt.fetch_order(self.id) - self.results.append(result) + try: + result = self.market.ccxt.fetch_order(self.id) + self.results.append(result) + self.status = result["status"] + # Time at which the order started + self.timestamp = result["datetime"] + except OrderNotCached: + self.status = "closed_unknown" - self.status = result["status"] - # Time at which the order started - self.timestamp = result["datetime"] self.fetch_mouvements() + self.mark_finished_order() # FIXME: consider open order with dust remaining as closed def dust_amount_remaining(self): return self.remaining_amount() < Amount(self.amount.currency, D("0.001")) def remaining_amount(self): - if self.status == "open": - self.fetch() return self.amount - self.filled_amount() def filled_amount(self, in_base_currency=False): @@ -631,8 +655,12 @@ class Order: self.market.report.log_debug_action("Mark {} as cancelled".format(self)) self.status = "canceled" return - self.market.ccxt.cancel_order(self.id) - self.fetch() + if self.open and self.id is not None: + try: + self.market.ccxt.cancel_order(self.id) + except OrderNotFound as e: # Closed inbetween + self.market.report.log_error("cancel_order", message="Already cancelled order", exception=e) + self.fetch() class Mouvement: def __init__(self, currency, base_currency, hash_):