portfolio.py

   1 import time
   2 from datetime import datetime, timedelta
   3 from decimal import Decimal as D, ROUND_DOWN
   4 from json import JSONDecodeError
   5 from simplejson.errors import JSONDecodeError as SimpleJSONDecodeError
   6 from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder, OrderNotCached, OrderNotFound
   7 from retry import retry
   8 import requests
   9
  10 # FIXME: correctly handle web call timeouts
  11
  12 class Portfolio:
  13     URL = "https://cryptoportfolio.io/wp-content/uploads/portfolio/json/cryptoportfolio.json"
  14     liquidities = {}
  15     data = None
  16     last_date = None
  17
  18     @classmethod
  19     def wait_for_recent(cls, market, delta=4):
  20         cls.repartition(market, refetch=True)
  21         while cls.last_date is None or datetime.now() - cls.last_date > timedelta(delta):
  22             time.sleep(30)
  23             market.report.print_log("Attempt to fetch up-to-date cryptoportfolio")
  24             cls.repartition(market, refetch=True)
  25
  26     @classmethod
  27     def repartition(cls, market, liquidity="medium", refetch=False):
  28         cls.parse_cryptoportfolio(market, refetch=refetch)
  29         liquidities = cls.liquidities[liquidity]
  30         return liquidities[cls.last_date]
  31
  32     @classmethod
  33     def get_cryptoportfolio(cls, market):
  34         try:
  35             r = requests.get(cls.URL)
  36             market.report.log_http_request(r.request.method,
  37                     r.request.url, r.request.body, r.request.headers, r)
  38         except Exception as e:
  39             market.report.log_error("get_cryptoportfolio", exception=e)
  40             return
  41         try:
  42             cls.data = r.json(parse_int=D, parse_float=D)
  43         except (JSONDecodeError, SimpleJSONDecodeError):
  44             cls.data = None
  45
  46     @classmethod
  47     def parse_cryptoportfolio(cls, market, refetch=False):
  48         if refetch or cls.data is None:
  49             cls.get_cryptoportfolio(market)
  50
  51         def filter_weights(weight_hash):
  52             if weight_hash[1][0] == 0:
  53                 return False
  54             if weight_hash[0] == "_row":
  55                 return False
  56             return True
  57
  58         def clean_weights(i):
  59             def clean_weights_(h):
  60                 if h[0].endswith("s"):
  61                     return [h[0][0:-1], (h[1][i], "short")]
  62                 else:
  63                     return [h[0], (h[1][i], "long")]
  64             return clean_weights_
  65
  66         def parse_weights(portfolio_hash):
  67             weights_hash = portfolio_hash["weights"]
  68             weights = {}
  69             for i in range(len(weights_hash["_row"])):
  70                 date = datetime.strptime(weights_hash["_row"][i], "%Y-%m-%d")
  71                 weights[date] = dict(filter(
  72                         filter_weights,
  73                         map(clean_weights(i), weights_hash.items())))
  74             return weights
  75
  76         high_liquidity = parse_weights(cls.data["portfolio_1"])
  77         medium_liquidity = parse_weights(cls.data["portfolio_2"])
  78
  79         cls.liquidities = {
  80                 "medium": medium_liquidity,
  81                 "high":   high_liquidity,
  82                 }
  83         cls.last_date = max(max(medium_liquidity.keys()), max(high_liquidity.keys()))
  84
  85 class Computation:
  86     computations = {
  87             "default": lambda x, y: x[y],
  88             "average": lambda x, y: x["average"],
  89             "bid": lambda x, y: x["bid"],
  90             "ask": lambda x, y: x["ask"],
  91             }
  92
  93     @classmethod
  94     def compute_value(cls, ticker, action, compute_value="default"):
  95         if action == "buy":
  96             action = "ask"
  97         if action == "sell":
  98             action = "bid"
  99         if isinstance(compute_value, str):
 100             compute_value = cls.computations[compute_value]
 101         return compute_value(ticker, action)
 102
 103 class Amount:
 104     def __init__(self, currency, value, linked_to=None, ticker=None, rate=None):
 105         self.currency = currency
 106         self.value = D(value)
 107         self.linked_to = linked_to
 108         self.ticker = ticker
 109         self.rate = rate
 110
 111     def in_currency(self, other_currency, market, rate=None, action=None, compute_value="average"):
 112         if other_currency == self.currency:
 113             return self
 114         if rate is not None:
 115             return Amount(
 116                     other_currency,
 117                     self.value * rate,
 118                     linked_to=self,
 119                     rate=rate)
 120         asset_ticker = market.get_ticker(self.currency, other_currency)
 121         if asset_ticker is not None:
 122             rate = Computation.compute_value(asset_ticker, action, compute_value=compute_value)
 123             return Amount(
 124                     other_currency,
 125                     self.value * rate,
 126                     linked_to=self,
 127                     ticker=asset_ticker,
 128                     rate=rate)
 129         else:
 130             raise Exception("This asset is not available in the chosen market")
 131
 132     def as_json(self):
 133         return {
 134                 "currency": self.currency,
 135                 "value": round(self).value.normalize(),
 136                 }
 137
 138     def __round__(self, n=8):
 139         return Amount(self.currency, self.value.quantize(D(1)/D(10**n), rounding=ROUND_DOWN))
 140
 141     def __abs__(self):
 142         return Amount(self.currency, abs(self.value))
 143
 144     def __add__(self, other):
 145         if other == 0:
 146             return self
 147         if other.currency != self.currency and other.value * self.value != 0:
 148             raise Exception("Summing amounts must be done with same currencies")
 149         return Amount(self.currency, self.value + other.value)
 150
 151     def __radd__(self, other):
 152         if other == 0:
 153             return self
 154         else:
 155             return self.__add__(other)
 156
 157     def __sub__(self, other):
 158         if other == 0:
 159             return self
 160         if other.currency != self.currency and other.value * self.value != 0:
 161             raise Exception("Summing amounts must be done with same currencies")
 162         return Amount(self.currency, self.value - other.value)
 163
 164     def __rsub__(self, other):
 165         if other == 0:
 166             return -self
 167         else:
 168             return -self.__sub__(other)
 169
 170     def __mul__(self, value):
 171         if not isinstance(value, (int, float, D)):
 172             raise TypeError("Amount may only be multiplied by numbers")
 173         return Amount(self.currency, self.value * value)
 174
 175     def __rmul__(self, value):
 176         return self.__mul__(value)
 177
 178     def __floordiv__(self, value):
 179         if not isinstance(value, (int, float, D)):
 180             raise TypeError("Amount may only be divided by numbers")
 181         return Amount(self.currency, self.value / value)
 182
 183     def __truediv__(self, value):
 184         return self.__floordiv__(value)
 185
 186     def __lt__(self, other):
 187         if other == 0:
 188             return self.value < 0
 189         if self.currency != other.currency:
 190             raise Exception("Comparing amounts must be done with same currencies")
 191         return self.value < other.value
 192
 193     def __le__(self, other):
 194         return self == other or self < other
 195
 196     def __gt__(self, other):
 197         return not self <= other
 198
 199     def __ge__(self, other):
 200         return not self < other
 201
 202     def __eq__(self, other):
 203         if other == 0:
 204             return self.value == 0
 205         if self.currency != other.currency:
 206             raise Exception("Comparing amounts must be done with same currencies")
 207         return self.value == other.value
 208
 209     def __ne__(self, other):
 210         return not self == other
 211
 212     def __neg__(self):
 213         return Amount(self.currency, - self.value)
 214
 215     def __str__(self):
 216         if self.linked_to is None:
 217             return "{:.8f} {}".format(self.value, self.currency)
 218         else:
 219             return "{:.8f} {} [{}]".format(self.value, self.currency, self.linked_to)
 220
 221     def __repr__(self):
 222         if self.linked_to is None:
 223             return "Amount({:.8f} {})".format(self.value, self.currency)
 224         else:
 225             return "Amount({:.8f} {} -> {})".format(self.value, self.currency, repr(self.linked_to))
 226
 227 class Balance:
 228     base_keys = ["total", "exchange_total", "exchange_used",
 229             "exchange_free", "margin_total", "margin_in_position",
 230             "margin_available", "margin_borrowed", "margin_pending_gain"]
 231
 232     def __init__(self, currency, hash_):
 233         self.currency = currency
 234         for key in self.base_keys:
 235             setattr(self, key, Amount(currency, hash_.get(key, 0)))
 236
 237         self.margin_position_type = hash_.get("margin_position_type")
 238
 239         if hash_.get("margin_borrowed_base_currency") is not None:
 240             base_currency = hash_["margin_borrowed_base_currency"]
 241             for key in [
 242                     "margin_liquidation_price",
 243                     "margin_lending_fees",
 244                     "margin_pending_base_gain",
 245                     "margin_borrowed_base_price"
 246                     ]:
 247                 setattr(self, key, Amount(base_currency, hash_.get(key, 0)))
 248
 249     def as_json(self):
 250         return dict(map(lambda x: (x, getattr(self, x).as_json()["value"]), self.base_keys))
 251
 252     def __repr__(self):
 253         if self.exchange_total > 0:
 254             if self.exchange_free > 0 and self.exchange_used > 0:
 255                 exchange = " Exch: [✔{} + ❌{} = {}]".format(str(self.exchange_free), str(self.exchange_used), str(self.exchange_total))
 256             elif self.exchange_free > 0:
 257                 exchange = " Exch: [✔{}]".format(str(self.exchange_free))
 258             else:
 259                 exchange = " Exch: [❌{}]".format(str(self.exchange_used))
 260         else:
 261             exchange = ""
 262
 263         if self.margin_total > 0:
 264             if self.margin_available != 0 and self.margin_in_position != 0:
 265                 margin = " Margin: [✔{} + ❌{} = {}]".format(str(self.margin_available), str(self.margin_in_position), str(self.margin_total))
 266             elif self.margin_available != 0:
 267                 margin = " Margin: [✔{}]".format(str(self.margin_available))
 268             else:
 269                 margin = " Margin: [❌{}]".format(str(self.margin_in_position))
 270         elif self.margin_total < 0:
 271             margin = " Margin: [{} @@ {}/{}]".format(str(self.margin_total),
 272                     str(self.margin_borrowed_base_price),
 273                     str(self.margin_lending_fees))
 274         else:
 275             margin = ""
 276
 277         if self.margin_total != 0 and self.exchange_total != 0:
 278             total = " Total: [{}]".format(str(self.total))
 279         else:
 280             total = ""
 281
 282         return "Balance({}".format(self.currency) + "".join([exchange, margin, total]) + ")"
 283
 284 class Trade:
 285     def __init__(self, value_from, value_to, currency, market):
 286         # We have value_from of currency, and want to finish with value_to of
 287         # that currency. value_* may not be in currency's terms
 288         self.currency = currency
 289         self.value_from = value_from
 290         self.value_to = value_to
 291         self.orders = []
 292         self.market = market
 293         self.closed = False
 294         self.inverted = None
 295         assert self.value_from.value * self.value_to.value >= 0
 296         assert self.value_from.currency == self.value_to.currency
 297         if self.value_from != 0:
 298             assert self.value_from.linked_to is not None and self.value_from.linked_to.currency == self.currency
 299         elif self.value_from.linked_to is None:
 300             self.value_from.linked_to = Amount(self.currency, 0)
 301         self.base_currency = self.value_from.currency
 302
 303     @property
 304     def delta(self):
 305         return self.value_to - self.value_from
 306
 307     @property
 308     def action(self):
 309         if self.value_from == self.value_to:
 310             return None
 311         if self.base_currency == self.currency:
 312             return None
 313
 314         if abs(self.value_from) < abs(self.value_to):
 315             return "acquire"
 316         else:
 317             return "dispose"
 318
 319     def order_action(self):
 320         if (self.value_from < self.value_to) != self.inverted:
 321             return "buy"
 322         else:
 323             return "sell"
 324
 325     @property
 326     def trade_type(self):
 327         if self.value_from + self.value_to < 0:
 328             return "short"
 329         else:
 330             return "long"
 331
 332     @property
 333     def pending(self):
 334         return not (self.is_fullfiled or self.closed)
 335
 336     def close(self):
 337         for order in self.orders:
 338             order.cancel()
 339         self.closed = True
 340
 341     @property
 342     def is_fullfiled(self):
 343         return abs(self.filled_amount(in_base_currency=(not self.inverted))) >= abs(self.delta)
 344
 345     def filled_amount(self, in_base_currency=False):
 346         filled_amount = 0
 347         for order in self.orders:
 348             filled_amount += order.filled_amount(in_base_currency=in_base_currency)
 349         return filled_amount
 350
 351     def update_order(self, order, tick):
 352         actions = {
 353                 0: ["waiting", None],
 354                 1: ["waiting", None],
 355                 2: ["adjusting", lambda x, y: (x[y] + x["average"]) / 2],
 356                 3: ["waiting", None],
 357                 4: ["waiting", None],
 358                 5: ["adjusting", lambda x, y: (x[y]*2 + x["average"]) / 3],
 359                 6: ["waiting", None],
 360                 7: ["market_fallback", "default"],
 361                 }
 362
 363         if tick in actions:
 364             update, compute_value = actions[tick]
 365         elif tick % 3 == 1:
 366             update = "market_adjust"
 367             compute_value = "default"
 368         else:
 369             update = "waiting"
 370             compute_value = None
 371
 372         if compute_value is not None:
 373             order.cancel()
 374             new_order = self.prepare_order(compute_value=compute_value)
 375         else:
 376             new_order = None
 377
 378         self.market.report.log_order(order, tick, update=update,
 379                 compute_value=compute_value, new_order=new_order)
 380
 381         if new_order is not None:
 382             new_order.run()
 383             self.market.report.log_order(order, tick, new_order=new_order)
 384
 385     def prepare_order(self, close_if_possible=None, compute_value="default"):
 386         if self.action is None:
 387             return None
 388         ticker = self.market.get_ticker(self.currency, self.base_currency)
 389         self.inverted = ticker["inverted"]
 390         if self.inverted:
 391             ticker = ticker["original"]
 392         rate = Computation.compute_value(ticker, self.order_action(), compute_value=compute_value)
 393
 394         # FIXME: Dust amount should be removed from there if they werent
 395         # honored in other sales
 396         delta_in_base = abs(self.delta)
 397         # 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
 398
 399         if not self.inverted:
 400             base_currency = self.base_currency
 401             # BTC
 402             if self.action == "dispose":
 403                 filled = self.filled_amount(in_base_currency=False)
 404                 delta = delta_in_base.in_currency(self.currency, self.market, rate=1/self.value_from.rate)
 405                 # I have 10 BTC worth of FOO, and I want to sell 9 BTC
 406                 # worth of it, computed first with rate 10 FOO = 1 BTC.
 407                 # -> I "sell" "90" FOO at proposed rate "rate".
 408
 409                 delta = delta - filled
 410                 # I already sold 60 FOO, 30 left
 411             else:
 412                 filled = self.filled_amount(in_base_currency=True)
 413                 delta = (delta_in_base - filled).in_currency(self.currency, self.market, rate=1/rate)
 414                 # I want to buy 9 BTC worth of FOO, computed with rate
 415                 # 10 FOO = 1 BTC
 416                 # -> I "buy" "9 / rate" FOO at proposed rate "rate"
 417
 418                 # I already bought 3 / rate FOO, 6 / rate left
 419         else:
 420             base_currency = self.currency
 421             # FOO
 422             if self.action == "dispose":
 423                 filled = self.filled_amount(in_base_currency=True)
 424                 # Base is FOO
 425
 426                 delta = (delta_in_base.in_currency(self.currency, self.market, rate=1/self.value_from.rate)
 427                         - filled).in_currency(self.base_currency, self.market, rate=1/rate)
 428                 # I have 10 BTC worth of FOO, and I want to sell 9 BTC worth of it
 429                 # computed at rate 1 Foo = 0.01 BTC
 430                 # Computation says I should sell it at 125 FOO / BTC
 431                 # -> delta_in_base = 9 BTC
 432                 # -> delta = (9 * 1/0.01 FOO) * 1/125 = 7.2 BTC
 433                 # Action: "buy" "7.2 BTC" at rate "125" "FOO" on market
 434
 435                 # I already bought 300/125 BTC, only 600/125 left
 436             else:
 437                 filled = self.filled_amount(in_base_currency=False)
 438                 # Base is FOO
 439
 440                 delta = delta_in_base
 441                 # I have 1 BTC worth of FOO, and I want to buy 9 BTC worth of it
 442                 # At rate 100 Foo / BTC
 443                 # Computation says I should buy it at 125 FOO / BTC
 444                 # -> delta_in_base = 9 BTC
 445                 # Action: "sell" "9 BTC" at rate "125" "FOO" on market
 446
 447                 delta = delta - filled
 448                 # I already sold 4 BTC, only 5 left
 449
 450         if close_if_possible is None:
 451             close_if_possible = (self.value_to == 0)
 452
 453         if delta <= 0:
 454             self.market.report.log_error("prepare_order", message="Less to do than already filled: {}".format(delta))
 455             return None
 456
 457         order = Order(self.order_action(),
 458             delta, rate, base_currency, self.trade_type,
 459             self.market, self, close_if_possible=close_if_possible)
 460         self.orders.append(order)
 461         return order
 462
 463     def as_json(self):
 464         return {
 465                 "action": self.action,
 466                 "from": self.value_from.as_json()["value"],
 467                 "to": self.value_to.as_json()["value"],
 468                 "currency": self.currency,
 469                 "base_currency": self.base_currency,
 470                 }
 471
 472     def __repr__(self):
 473         if self.closed and not self.is_fullfiled:
 474             closed = " ❌"
 475         elif self.is_fullfiled:
 476             closed = " ✔"
 477         else:
 478             closed = ""
 479
 480         return "Trade({} -> {} in {}, {}{})".format(
 481                 self.value_from,
 482                 self.value_to,
 483                 self.currency,
 484                 self.action,
 485                 closed)
 486
 487     def print_with_order(self, ind=""):
 488         self.market.report.print_log("{}{}".format(ind, self))
 489         for order in self.orders:
 490             self.market.report.print_log("{}\t{}".format(ind, order))
 491             for mouvement in order.mouvements:
 492                 self.market.report.print_log("{}\t\t{}".format(ind, mouvement))
 493
 494 class Order:
 495     def __init__(self, action, amount, rate, base_currency, trade_type, market,
 496             trade, close_if_possible=False):
 497         self.action = action
 498         self.amount = amount
 499         self.rate = rate
 500         self.base_currency = base_currency
 501         self.market = market
 502         self.trade_type = trade_type
 503         self.results = []
 504         self.mouvements = []
 505         self.status = "pending"
 506         self.trade = trade
 507         self.close_if_possible = close_if_possible
 508         self.id = None
 509         self.tries = 0
 510
 511     def as_json(self):
 512         return {
 513                 "action": self.action,
 514                 "trade_type": self.trade_type,
 515                 "amount": self.amount.as_json()["value"],
 516                 "currency": self.amount.as_json()["currency"],
 517                 "base_currency": self.base_currency,
 518                 "rate": self.rate,
 519                 "status": self.status,
 520                 "close_if_possible": self.close_if_possible,
 521                 "id": self.id,
 522                 "mouvements": list(map(lambda x: x.as_json(), self.mouvements))
 523                 }
 524
 525     def __repr__(self):
 526         return "Order({} {} {} at {} {} [{}]{})".format(
 527                 self.action,
 528                 self.trade_type,
 529                 self.amount,
 530                 self.rate,
 531                 self.base_currency,
 532                 self.status,
 533                 " ✂" if self.close_if_possible else "",
 534                 )
 535
 536     @property
 537     def account(self):
 538         if self.trade_type == "long":
 539             return "exchange"
 540         else:
 541             return "margin"
 542
 543     @property
 544     def open(self):
 545         return self.status == "open"
 546
 547     @property
 548     def pending(self):
 549         return self.status == "pending"
 550
 551     @property
 552     def finished(self):
 553         return self.status.startswith("closed") or self.status == "canceled" or self.status == "error"
 554
 555     @retry(InsufficientFunds)
 556     def run(self):
 557         self.tries += 1
 558         symbol = "{}/{}".format(self.amount.currency, self.base_currency)
 559         amount = round(self.amount, self.market.ccxt.order_precision(symbol)).value
 560
 561         if self.market.debug:
 562             self.market.report.log_debug_action("market.ccxt.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(
 563                 symbol, self.action, amount, self.rate, self.account))
 564             self.results.append({"debug": True, "id": -1})
 565         else:
 566             action = "market.ccxt.create_order('{}', 'limit', '{}', {}, price={}, account={})".format(symbol, self.action, amount, self.rate, self.account)
 567             try:
 568                 self.results.append(self.market.ccxt.create_order(symbol, 'limit', self.action, amount, price=self.rate, account=self.account))
 569             except InvalidOrder:
 570                 # Impossible to honor the order (dust amount)
 571                 self.status = "closed"
 572                 self.mark_finished_order()
 573                 return
 574             except InsufficientFunds as e:
 575                 if self.tries < 5:
 576                     self.market.report.log_error(action, message="Retrying with reduced amount", exception=e)
 577                     self.amount = self.amount * D("0.99")
 578                     raise e
 579                 else:
 580                     self.market.report.log_error(action, message="Giving up {}".format(self), exception=e)
 581                     self.status = "error"
 582                     return
 583             except Exception as e:
 584                 self.status = "error"
 585                 self.market.report.log_error(action, exception=e)
 586                 return
 587         self.id = self.results[0]["id"]
 588         self.status = "open"
 589
 590     def get_status(self):
 591         if self.market.debug:
 592             self.market.report.log_debug_action("Getting {} status".format(self))
 593             return self.status
 594         # other states are "closed" and "canceled"
 595         if not self.finished:
 596             self.fetch()
 597         return self.status
 598
 599     def mark_finished_order(self):
 600         if self.status.startswith("closed") and self.market.debug:
 601             self.market.report.log_debug_action("Mark {} as finished".format(self))
 602             return
 603         if self.status.startswith("closed"):
 604             if self.trade_type == "short" and self.action == "buy" and self.close_if_possible:
 605                 self.market.ccxt.close_margin_position(self.amount.currency, self.base_currency)
 606
 607     def fetch(self):
 608         if self.market.debug:
 609             self.market.report.log_debug_action("Fetching {}".format(self))
 610             return
 611         try:
 612             result = self.market.ccxt.fetch_order(self.id)
 613             self.results.append(result)
 614             self.status = result["status"]
 615             # Time at which the order started
 616             self.timestamp = result["datetime"]
 617         except OrderNotCached:
 618             self.status = "closed_unknown"
 619
 620         self.fetch_mouvements()
 621
 622         self.mark_finished_order()
 623         # FIXME: consider open order with dust remaining as closed
 624
 625     def dust_amount_remaining(self):
 626         return self.remaining_amount() < Amount(self.amount.currency, D("0.001"))
 627
 628     def remaining_amount(self):
 629         return self.amount - self.filled_amount()
 630
 631     def filled_amount(self, in_base_currency=False):
 632         if self.status == "open":
 633             self.fetch()
 634         filled_amount = 0
 635         for mouvement in self.mouvements:
 636             if in_base_currency:
 637                 filled_amount += mouvement.total_in_base
 638             else:
 639                 filled_amount += mouvement.total
 640         return filled_amount
 641
 642     def fetch_mouvements(self):
 643         try:
 644             mouvements = self.market.ccxt.privatePostReturnOrderTrades({"orderNumber": self.id})
 645         except ExchangeError:
 646             mouvements = []
 647         self.mouvements = []
 648
 649         for mouvement_hash in mouvements:
 650             self.mouvements.append(Mouvement(self.amount.currency,
 651                 self.base_currency, mouvement_hash))
 652
 653     def cancel(self):
 654         if self.market.debug:
 655             self.market.report.log_debug_action("Mark {} as cancelled".format(self))
 656             self.status = "canceled"
 657             return
 658         if self.open and self.id is not None:
 659             try:
 660                 self.market.ccxt.cancel_order(self.id)
 661             except OrderNotFound as e: # Closed inbetween
 662                 self.market.report.log_error("cancel_order", message="Already cancelled order", exception=e)
 663             self.fetch()
 664
 665 class Mouvement:
 666     def __init__(self, currency, base_currency, hash_):
 667         self.currency = currency
 668         self.base_currency = base_currency
 669         self.id = hash_.get("tradeID")
 670         self.action = hash_.get("type")
 671         self.fee_rate = D(hash_.get("fee", -1))
 672         try:
 673             self.date = datetime.strptime(hash_.get("date", ""), '%Y-%m-%d %H:%M:%S')
 674         except ValueError:
 675             self.date = None
 676         self.rate = D(hash_.get("rate", 0))
 677         self.total = Amount(currency, hash_.get("amount", 0))
 678         # rate * total = total_in_base
 679         self.total_in_base = Amount(base_currency, hash_.get("total", 0))
 680
 681     def as_json(self):
 682         return {
 683                 "fee_rate": self.fee_rate,
 684                 "date": self.date,
 685                 "action": self.action,
 686                 "total": self.total.value,
 687                 "currency": self.currency,
 688                 "total_in_base": self.total_in_base.value,
 689                 "base_currency": self.base_currency
 690                 }
 691
 692     def __repr__(self):
 693         if self.fee_rate > 0:
 694             fee_rate = " fee: {}%".format(self.fee_rate * 100)
 695         else:
 696             fee_rate = ""
 697         if self.date is None:
 698             date = "No date"
 699         else:
 700             date = self.date
 701         return "Mouvement({} ; {} {} ({}){})".format(
 702                 date, self.action, self.total, self.total_in_base,
 703                 fee_rate)
 704