Remove useless update_trades method

Add arguments to log_stage

4 files changed, 38 insertions, 68 deletions

diff --git a/helper.py b/helper.py
index 83e981b..be480e2 100644
--- a/helper.py
+++ b/helper.py
@@ -173,7 +173,7 @@ def process_sell_needed__1_sell(market, liquidity="medium", base_currency="BTC")
 def process_sell_needed__2_buy(market, liquidity="medium", base_currency="BTC"):
     market.report.log_stage("process_sell_needed__2_buy_begin")
     market.balances.fetch_balances(tag="process_sell_needed__2_buy_begin")
-    market.update_trades(base_currency=base_currency, liquidity=liquidity, only="acquire")
+    market.prepare_trades(base_currency=base_currency, liquidity=liquidity, only="acquire")
     market.trades.prepare_orders(compute_value="average", only="acquire")
     market.move_balances()
     market.trades.run_orders()
diff --git a/market.py b/market.py
index 0d91f17..ca365bd 100644
--- a/market.py
+++ b/market.py
@@ -128,17 +128,10 @@ class Market:
                     order.trade.update_order(order, tick)
         self.report.log_stage("follow_orders_end")
 
-    def prepare_trades(self, base_currency="BTC", liquidity="medium", compute_value="average"):
-        self.report.log_stage("prepare_trades")
-        values_in_base = self.balances.in_currency(base_currency, compute_value=compute_value)
-        total_base_value = sum(values_in_base.values())
-        new_repartition = self.balances.dispatch_assets(total_base_value, liquidity=liquidity)
-        # Recompute it in case we have new currencies
-        values_in_base = self.balances.in_currency(base_currency, compute_value=compute_value)
-        self.trades.compute_trades(values_in_base, new_repartition)
-
-    def update_trades(self, base_currency="BTC", liquidity="medium", compute_value="average", only=None):
-        self.report.log_stage("update_trades")
+    def prepare_trades(self, base_currency="BTC", liquidity="medium", compute_value="average", only=None):
+        self.report.log_stage("prepare_trades",
+                base_currency=base_currency, liquidity=liquidity,
+                compute_value=compute_value, only=only)
         values_in_base = self.balances.in_currency(base_currency, compute_value=compute_value)
         total_base_value = sum(values_in_base.values())
         new_repartition = self.balances.dispatch_assets(total_base_value, liquidity=liquidity)
diff --git a/store.py b/store.py
index c581608..43fee03 100644
--- a/store.py
+++ b/store.py
@@ -32,13 +32,24 @@ class ReportStore:
     def set_verbose(self, verbose_print):
         self.verbose_print = verbose_print
 
-    def log_stage(self, stage):
+    def log_stage(self, stage, **kwargs):
+        def as_json(element):
+            if callable(element):
+                return inspect.getsource(element).strip()
+            elif hasattr(element, "as_json"):
+                return element.as_json()
+            else:
+                return element
+
+        args = { k: as_json(v) for k, v in kwargs.items() }
+        args_str = ["{}={}".format(k, v) for k, v in args.items()]
         self.print_log("-" * (len(stage) + 8))
-        self.print_log("[Stage] {}".format(stage))
+        self.print_log("[Stage] {} {}".format(stage, ", ".join(args_str)))
 
         self.add_log({
             "type": "stage",
             "stage": stage,
+            "args": args,
             })
 
     def log_balances(self, tag=None):
diff --git a/test.py b/test.py
index 235f618..7ec8ba7 100644
--- a/test.py
+++ b/test.py
@@ -781,55 +781,9 @@ class MarketTest(WebMockTestCase):
             self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
             self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
             self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
-            m.report.log_stage.assert_called_once_with("prepare_trades")
-            m.report.log_balances.assert_called_once_with(tag="tag")
-
-    @mock.patch.object(portfolio.Portfolio, "repartition")
-    @mock.patch.object(market.Market, "get_ticker")
-    @mock.patch.object(market.TradeStore, "compute_trades")
-    def test_update_trades(self, compute_trades, get_ticker, repartition):
-        repartition.return_value = {
-                "XEM": (D("0.75"), "long"),
-                "BTC": (D("0.25"), "long"),
-                }
-        def _get_ticker(c1, c2):
-            if c1 == "USDT" and c2 == "BTC":
-                return { "average": D("0.0001") }
-            if c1 == "XVG" and c2 == "BTC":
-                return { "average": D("0.000001") }
-            if c1 == "XEM" and c2 == "BTC":
-                return { "average": D("0.001") }
-            self.fail("Should be called with {}, {}".format(c1, c2))
-        get_ticker.side_effect = _get_ticker
-
-        with mock.patch("market.ReportStore"):
-            m = market.Market(self.ccxt)
-            self.ccxt.fetch_all_balances.return_value = {
-                    "USDT": {
-                        "exchange_free": D("10000.0"),
-                        "exchange_used": D("0.0"),
-                        "exchange_total": D("10000.0"),
-                        "total": D("10000.0")
-                        },
-                    "XVG": {
-                        "exchange_free": D("10000.0"),
-                        "exchange_used": D("0.0"),
-                        "exchange_total": D("10000.0"),
-                        "total": D("10000.0")
-                        },
-                    }
-
-            m.balances.fetch_balances(tag="tag")
-
-            m.update_trades()
-            compute_trades.assert_called()
-
-            call = compute_trades.call_args
-            self.assertEqual(1, call[0][0]["USDT"].value)
-            self.assertEqual(D("0.01"), call[0][0]["XVG"].value)
-            self.assertEqual(D("0.2525"), call[0][1]["BTC"].value)
-            self.assertEqual(D("0.7575"), call[0][1]["XEM"].value)
-            m.report.log_stage.assert_called_once_with("update_trades")
+            m.report.log_stage.assert_called_once_with("prepare_trades",
+                    base_currency='BTC', compute_value='average',
+                    liquidity='medium', only=None)
             m.report.log_balances.assert_called_once_with(tag="tag")
 
     @mock.patch.object(portfolio.Portfolio, "repartition")
@@ -2356,12 +2310,24 @@ class ReportStoreTest(WebMockTestCase):
     @mock.patch.object(market.ReportStore, "add_log")
     def test_log_stage(self, add_log, print_log):
         report_store = market.ReportStore(self.m)
-        report_store.log_stage("foo")
+        c = lambda x: x
+        report_store.log_stage("foo", bar="baz", c=c, d=portfolio.Amount("BTC", 1))
         print_log.assert_has_calls([
             mock.call("-----------"),
-            mock.call("[Stage] foo"),
+            mock.call("[Stage] foo bar=baz, c=c = lambda x: x, d={'currency': 'BTC', 'value': Decimal('1')}"),
             ])
-        add_log.assert_called_once_with({'type': 'stage', 'stage': 'foo'})
+        add_log.assert_called_once_with({
+            'type': 'stage',
+            'stage': 'foo',
+            'args': {
+                'bar': 'baz',
+                'c': 'c = lambda x: x',
+                'd': {
+                    'currency': 'BTC',
+                    'value': D('1')
+                    }
+                }
+            })
 
     @mock.patch.object(market.ReportStore, "print_log")
     @mock.patch.object(market.ReportStore, "add_log")
@@ -3089,7 +3055,7 @@ class HelperTest(WebMockTestCase):
             mock.call(tag="process_sell_needed__2_buy_begin"),
             mock.call(tag="process_sell_needed__2_buy_end"),
             ])
-        self.m.update_trades.assert_called_with(base_currency="BTC",
+        self.m.prepare_trades.assert_called_with(base_currency="BTC",
                 liquidity="medium", only="acquire")
         self.m.trades.prepare_orders.assert_called_with(compute_value="average",
                 only="acquire")
@@ -3346,7 +3312,7 @@ class AcceptanceTest(WebMockTestCase):
 
         with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
             # Action 5
-            helper.update_trades(market, only="acquire", compute_value="average")
+            helper.prepare_trades(market, only="acquire", compute_value="average")
 
         balances = portfolio.BalanceStore.all
         self.assertEqual(portfolio.Amount("ETH", 1 / D("3")), balances["ETH"].total)