Merge branch 'night_fixes' into dev

[perso/Immae/Projets/Cryptomonnaies/Cryptoportfolio/Trader.git] / portfolio.py

diff --git a/portfolio.py b/portfolio.py
index 0f2c011fb4063e2a5f50fb4afb878d2f7573d40e..69e37557fd9cd355fbdccabcd1fb993fbf9adef1 100644 (file)
--- a/portfolio.py
+++ b/portfolio.py
@@ -1,87 +1,10 @@
-import time
-from datetime import datetime, timedelta
+from datetime import datetime

 from decimal import Decimal as D, ROUND_DOWN
 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, OrderNotCached, OrderNotFound
 from retry import retry
 from ccxt import ExchangeError, InsufficientFunds, ExchangeNotAvailable, InvalidOrder, OrderNotCached, OrderNotFound
 from retry import retry

-import requests

 
 # FIXME: correctly handle web call timeouts
 
 
 # FIXME: correctly handle web call timeouts
 

-class Portfolio:
-    URL = "https://cryptoportfolio.io/wp-content/uploads/portfolio/json/cryptoportfolio.json"
-    liquidities = {}
-    data = None
-    last_date = None
-
-    @classmethod
-    def wait_for_recent(cls, market, delta=4):
-        cls.repartition(market, refetch=True)
-        while cls.last_date is None or datetime.now() - cls.last_date > timedelta(delta):
-            time.sleep(30)
-            market.report.print_log("Attempt to fetch up-to-date cryptoportfolio")
-            cls.repartition(market, refetch=True)
-
-    @classmethod
-    def repartition(cls, market, liquidity="medium", refetch=False):
-        cls.parse_cryptoportfolio(market, refetch=refetch)
-        liquidities = cls.liquidities[liquidity]
-        return liquidities[cls.last_date]
-
-    @classmethod
-    def get_cryptoportfolio(cls, market):
-        try:
-            r = requests.get(cls.URL)
-            market.report.log_http_request(r.request.method,
-                    r.request.url, r.request.body, r.request.headers, r)
-        except Exception as e:
-            market.report.log_error("get_cryptoportfolio", exception=e)
-            return
-        try:
-            cls.data = r.json(parse_int=D, parse_float=D)
-        except (JSONDecodeError, SimpleJSONDecodeError):
-            cls.data = None
-
-    @classmethod
-    def parse_cryptoportfolio(cls, market, refetch=False):
-        if refetch or cls.data is None:
-            cls.get_cryptoportfolio(market)
-
-        def filter_weights(weight_hash):
-            if weight_hash[1][0] == 0:
-                return False
-            if weight_hash[0] == "_row":
-                return False
-            return True
-
-        def clean_weights(i):
-            def clean_weights_(h):
-                if h[0].endswith("s"):
-                    return [h[0][0:-1], (h[1][i], "short")]
-                else:
-                    return [h[0], (h[1][i], "long")]
-            return clean_weights_
-
-        def parse_weights(portfolio_hash):
-            weights_hash = portfolio_hash["weights"]
-            weights = {}
-            for i in range(len(weights_hash["_row"])):
-                date = datetime.strptime(weights_hash["_row"][i], "%Y-%m-%d")
-                weights[date] = dict(filter(
-                        filter_weights,
-                        map(clean_weights(i), weights_hash.items())))
-            return weights
-
-        high_liquidity = parse_weights(cls.data["portfolio_1"])
-        medium_liquidity = parse_weights(cls.data["portfolio_2"])
-
-        cls.liquidities = {
-                "medium": medium_liquidity,
-                "high":   high_liquidity,
-                }
-        cls.last_date = max(max(medium_liquidity.keys()), max(high_liquidity.keys()))
-

 class Computation:
     computations = {
             "default": lambda x, y: x[y],
 class Computation:
     computations = {
             "default": lambda x, y: x[y],


@@ -291,6 +214,7 @@ class Trade:
         self.orders = []
         self.market = market
         self.closed = False
         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.value * self.value_to.value >= 0
         assert self.value_from.currency == self.value_to.currency
         if self.value_from != 0:


@@ -315,8 +239,8 @@ class Trade:
         else:
             return "dispose"
 
         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"
             return "buy"
         else:
             return "sell"


@@ -339,7 +263,7 @@ class Trade:
 
     @property
     def is_fullfiled(self):
 
     @property
     def is_fullfiled(self):

-        return abs(self.filled_amount(in_base_currency=True)) >= abs(self.delta)
+        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
 
     def filled_amount(self, in_base_currency=False):
         filled_amount = 0


@@ -385,17 +309,17 @@ class Trade:
         if self.action is None:
             return None
         ticker = self.market.get_ticker(self.currency, self.base_currency)
         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"]
             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)

 
         # FIXME: Dust amount should be removed from there if they werent
         # honored in other sales
         delta_in_base = abs(self.delta)
         # 9 BTC's worth of move (10 - 1 or 1 - 10 depending on case)
 
 
         # FIXME: Dust amount should be removed from there if they werent
         # honored in other sales
         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":
             base_currency = self.base_currency
             # BTC
             if self.action == "dispose":


@@ -453,7 +377,7 @@ class Trade:
             self.market.report.log_error("prepare_order", message="Less to do than already filled: {}".format(delta))
             return None
 
             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)
             delta, rate, base_currency, self.trade_type,
             self.market, self, close_if_possible=close_if_possible)
         self.orders.append(order)


@@ -549,7 +473,7 @@ class Order:
 
     @property
     def finished(self):
 
     @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):
 
     @retry(InsufficientFunds)
     def run(self):


@@ -593,15 +517,13 @@ class Order:
         # other states are "closed" and "canceled"
         if not self.finished:
             self.fetch()
         # 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):
         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
             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)
 
             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)
 


@@ -620,6 +542,7 @@ class Order:
 
         self.fetch_mouvements()
 
 
         self.fetch_mouvements()
 

+        self.mark_finished_order()

         # FIXME: consider open order with dust remaining as closed
 
     def dust_amount_remaining(self):
         # FIXME: consider open order with dust remaining as closed
 
     def dust_amount_remaining(self):