Move Portfolio to store and cleanup methods

Make report stored in portfolio class instead of market

diff --git a/market.py b/market.py
index 6c14ae208af3add2eb1bf65ab6627696945e8b22..388dea0cadb1265f966c1aa4afe2c66b85f93c26 100644 (file)
--- a/market.py
+++ b/market.py
@@ -312,7 +312,7 @@ class Processor:
         import inspect
 
         if action == "wait_for_recent":
         import inspect
 
         if action == "wait_for_recent":

-            method = portfolio.Portfolio.wait_for_recent
+            method = Portfolio.wait_for_recent

         elif action == "prepare_trades":
             method = self.market.prepare_trades
         elif action == "prepare_orders":
         elif action == "prepare_trades":
             method = self.market.prepare_trades
         elif action == "prepare_orders":


@@ -345,8 +345,4 @@ class Processor:
     def run_action(self, action, default_args, kwargs):
         method, args = self.parse_args(action, default_args, kwargs)
 
     def run_action(self, action, default_args, kwargs):
         method, args = self.parse_args(action, default_args, kwargs)
 

-        if action == "wait_for_recent":
-            method(self.market, **args)
-        else:
-            method(**args)
-
+        method(**args)

diff --git a/portfolio.py b/portfolio.py
index 0f2c011fb4063e2a5f50fb4afb878d2f7573d40e..554b34f090b8d179fead2742c8280f2100ded3bd 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],

diff --git a/store.py b/store.py
index d25dd35d1b06efe8f73b812c90cb1d51a66448cc..78dfe2dcba77390d3fffa42df937c1704b393949 100644 (file)
--- a/store.py
+++ b/store.py
@@ -1,10 +1,14 @@
+import time
+import requests

 import portfolio
 import simplejson as json
 from decimal import Decimal as D, ROUND_DOWN
 import portfolio
 import simplejson as json
 from decimal import Decimal as D, ROUND_DOWN

-from datetime import date, datetime
+from datetime import date, datetime, timedelta

 import inspect
 import inspect

+from json import JSONDecodeError
+from simplejson.errors import JSONDecodeError as SimpleJSONDecodeError

 
 

-__all__ = ["BalanceStore", "ReportStore", "TradeStore"]
+__all__ = ["Portfolio", "BalanceStore", "ReportStore", "TradeStore"]

 
 class ReportStore:
     def __init__(self, market, verbose_print=True):
 
 class ReportStore:
     def __init__(self, market, verbose_print=True):


@@ -213,7 +217,7 @@ class BalanceStore:
 
     def dispatch_assets(self, amount, liquidity="medium", repartition=None):
         if repartition is None:
 
     def dispatch_assets(self, amount, liquidity="medium", repartition=None):
         if repartition is None:

-            repartition = portfolio.Portfolio.repartition(self.market, liquidity=liquidity)
+            repartition = Portfolio.repartition(liquidity=liquidity)

         sum_ratio = sum([v[0] for k, v in repartition.items()])
         amounts = {}
         for currency, (ptt, trade_type) in repartition.items():
         sum_ratio = sum([v[0] for k, v in repartition.items()])
         amounts = {}
         for currency, (ptt, trade_type) in repartition.items():


@@ -301,4 +305,79 @@ class TradeStore:
         for order in self.all_orders(state="open"):
             order.get_status()
 
         for order in self.all_orders(state="open"):
             order.get_status()
 

+class Portfolio:
+    URL = "https://cryptoportfolio.io/wp-content/uploads/portfolio/json/cryptoportfolio.json"
+    liquidities = {}
+    data = None
+    last_date = None
+    report = ReportStore(None)
+
+    @classmethod
+    def wait_for_recent(cls, delta=4):
+        cls.get_cryptoportfolio()
+        while cls.last_date is None or datetime.now() - cls.last_date > timedelta(delta):
+            time.sleep(30)
+            cls.report.print_log("Attempt to fetch up-to-date cryptoportfolio")
+            cls.get_cryptoportfolio(refetch=True)
+
+    @classmethod
+    def repartition(cls, liquidity="medium"):
+        cls.get_cryptoportfolio()
+        liquidities = cls.liquidities[liquidity]
+        return liquidities[cls.last_date]
+
+    @classmethod
+    def get_cryptoportfolio(cls, refetch=False):
+        if cls.data is not None and not refetch:
+            return
+        try:
+            r = requests.get(cls.URL)
+            cls.report.log_http_request(r.request.method,
+                    r.request.url, r.request.body, r.request.headers, r)
+        except Exception as e:
+            cls.report.log_error("get_cryptoportfolio", exception=e)
+            return
+        try:
+            cls.data = r.json(parse_int=D, parse_float=D)
+            cls.parse_cryptoportfolio()
+        except (JSONDecodeError, SimpleJSONDecodeError):
+            cls.data = None
+            cls.liquidities = {}
+
+    @classmethod
+    def parse_cryptoportfolio(cls):
+        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()))
+

 
 

diff --git a/test.py b/test.py
index bbe0697bbfd47273106bddc29b8536320d4f34e7..d4432f6e7a87636efc8c94913382b385177a4841 100644 (file)
--- a/test.py
+++ b/test.py
@@ -7,7 +7,7 @@ from unittest import mock
 import requests
 import requests_mock
 from io import StringIO
 import requests
 import requests_mock
 from io import StringIO

-import portfolio, market, main
+import portfolio, market, main, store

 
 limits = ["acceptance", "unit"]
 for test_type in limits:
 
 limits = ["acceptance", "unit"]
 for test_type in limits:


@@ -32,7 +32,11 @@ class WebMockTestCase(unittest.TestCase):
         self.m.debug = False
 
         self.patchers = [
         self.m.debug = False
 
         self.patchers = [

-                mock.patch.multiple(portfolio.Portfolio, last_date=None, data=None, liquidities={}),
+                mock.patch.multiple(market.Portfolio,
+                    last_date=None,
+                    data=None,
+                    liquidities={},
+                    report=mock.Mock()),

                 mock.patch.multiple(portfolio.Computation,
                     computations=portfolio.Computation.computations),
                 ]
                 mock.patch.multiple(portfolio.Computation,
                     computations=portfolio.Computation.computations),
                 ]


@@ -439,57 +443,64 @@ class poloniexETest(unittest.TestCase):
 
 @unittest.skipUnless("unit" in limits, "Unit skipped")
 class PortfolioTest(WebMockTestCase):
 
 @unittest.skipUnless("unit" in limits, "Unit skipped")
 class PortfolioTest(WebMockTestCase):

-    def fill_data(self):
-        if self.json_response is not None:
-            portfolio.Portfolio.data = self.json_response
-

     def setUp(self):
         super(PortfolioTest, self).setUp()
 
         with open("test_samples/test_portfolio.json") as example:
             self.json_response = example.read()
 
     def setUp(self):
         super(PortfolioTest, self).setUp()
 
         with open("test_samples/test_portfolio.json") as example:
             self.json_response = example.read()
 

-        self.wm.get(portfolio.Portfolio.URL, text=self.json_response)
+        self.wm.get(market.Portfolio.URL, text=self.json_response)

 
 

-    def test_get_cryptoportfolio(self):
-        self.wm.get(portfolio.Portfolio.URL, [
+    @mock.patch.object(market.Portfolio, "parse_cryptoportfolio")
+    def test_get_cryptoportfolio(self, parse_cryptoportfolio):
+        self.wm.get(market.Portfolio.URL, [

             {"text":'{ "foo": "bar" }', "status_code": 200},
             {"text": "System Error", "status_code": 500},
             {"exc": requests.exceptions.ConnectTimeout},
             ])
             {"text":'{ "foo": "bar" }', "status_code": 200},
             {"text": "System Error", "status_code": 500},
             {"exc": requests.exceptions.ConnectTimeout},
             ])

-        portfolio.Portfolio.get_cryptoportfolio(self.m)
-        self.assertIn("foo", portfolio.Portfolio.data)
-        self.assertEqual("bar", portfolio.Portfolio.data["foo"])
+        market.Portfolio.get_cryptoportfolio()
+        self.assertIn("foo", market.Portfolio.data)
+        self.assertEqual("bar", market.Portfolio.data["foo"])

         self.assertTrue(self.wm.called)
         self.assertEqual(1, self.wm.call_count)
         self.assertTrue(self.wm.called)
         self.assertEqual(1, self.wm.call_count)

-        self.m.report.log_error.assert_not_called()
-        self.m.report.log_http_request.assert_called_once()
-        self.m.report.log_http_request.reset_mock()
-
-        portfolio.Portfolio.get_cryptoportfolio(self.m)
-        self.assertIsNone(portfolio.Portfolio.data)
+        market.Portfolio.report.log_error.assert_not_called()
+        market.Portfolio.report.log_http_request.assert_called_once()
+        parse_cryptoportfolio.assert_called_once_with()
+        market.Portfolio.report.log_http_request.reset_mock()
+        parse_cryptoportfolio.reset_mock()
+        market.Portfolio.data = None
+
+        market.Portfolio.get_cryptoportfolio()
+        self.assertIsNone(market.Portfolio.data)

         self.assertEqual(2, self.wm.call_count)
         self.assertEqual(2, self.wm.call_count)

-        self.m.report.log_error.assert_not_called()
-        self.m.report.log_http_request.assert_called_once()
-        self.m.report.log_http_request.reset_mock()
-
+        parse_cryptoportfolio.assert_not_called()
+        market.Portfolio.report.log_error.assert_not_called()
+        market.Portfolio.report.log_http_request.assert_called_once()
+        market.Portfolio.report.log_http_request.reset_mock()
+        parse_cryptoportfolio.reset_mock()
+
+        market.Portfolio.data = "Foo"
+        market.Portfolio.get_cryptoportfolio()
+        self.assertEqual(2, self.wm.call_count)
+        parse_cryptoportfolio.assert_not_called()

 
 

-        portfolio.Portfolio.data = "Foo"
-        portfolio.Portfolio.get_cryptoportfolio(self.m)
-        self.assertEqual("Foo", portfolio.Portfolio.data)
+        market.Portfolio.get_cryptoportfolio(refetch=True)
+        self.assertEqual("Foo", market.Portfolio.data)

         self.assertEqual(3, self.wm.call_count)
         self.assertEqual(3, self.wm.call_count)

-        self.m.report.log_error.assert_called_once_with("get_cryptoportfolio",
+        market.Portfolio.report.log_error.assert_called_once_with("get_cryptoportfolio",

                 exception=mock.ANY)
                 exception=mock.ANY)

-        self.m.report.log_http_request.assert_not_called()
+        market.Portfolio.report.log_http_request.assert_not_called()

 
     def test_parse_cryptoportfolio(self):
 
     def test_parse_cryptoportfolio(self):

-        portfolio.Portfolio.parse_cryptoportfolio(self.m)
+        market.Portfolio.data = store.json.loads(self.json_response, parse_int=D,
+                parse_float=D)
+        market.Portfolio.parse_cryptoportfolio()

 
         self.assertListEqual(
                 ["medium", "high"],
 
         self.assertListEqual(
                 ["medium", "high"],

-                list(portfolio.Portfolio.liquidities.keys()))
+                list(market.Portfolio.liquidities.keys()))

 
 

-        liquidities = portfolio.Portfolio.liquidities
+        liquidities = market.Portfolio.liquidities

         self.assertEqual(10, len(liquidities["medium"].keys()))
         self.assertEqual(10, len(liquidities["high"].keys()))
 
         self.assertEqual(10, len(liquidities["medium"].keys()))
         self.assertEqual(10, len(liquidities["high"].keys()))
 


@@ -517,94 +528,64 @@ class PortfolioTest(WebMockTestCase):
                 'XCP':  (D("0.1"), "long"),
                 }
         self.assertDictEqual(expected, liquidities["medium"][date])
                 'XCP':  (D("0.1"), "long"),
                 }
         self.assertDictEqual(expected, liquidities["medium"][date])

-        self.assertEqual(portfolio.datetime(2018, 1, 15), portfolio.Portfolio.last_date)
-
-        self.m.report.log_http_request.assert_called_once_with("GET",
-                portfolio.Portfolio.URL, None, mock.ANY, mock.ANY)
-        self.m.report.log_http_request.reset_mock()
-
-        # It doesn't refetch the data when available
-        portfolio.Portfolio.parse_cryptoportfolio(self.m)
-        self.m.report.log_http_request.assert_not_called()
-
-        self.assertEqual(1, self.wm.call_count)
-
-        portfolio.Portfolio.parse_cryptoportfolio(self.m, refetch=True)
-        self.assertEqual(2, self.wm.call_count)
-        self.m.report.log_http_request.assert_called_once()
-
-    def test_repartition(self):
-        expected_medium = {
-                'BTC':   (D("1.1102e-16"), "long"),
-                'USDT':  (D("0.1"), "long"),
-                'ETC':   (D("0.1"), "long"),
-                'FCT':   (D("0.1"), "long"),
-                'OMG':   (D("0.1"), "long"),
-                'STEEM': (D("0.1"), "long"),
-                'STRAT': (D("0.1"), "long"),
-                'XEM':   (D("0.1"), "long"),
-                'XMR':   (D("0.1"), "long"),
-                'XVC':   (D("0.1"), "long"),
-                'ZRX':   (D("0.1"), "long"),
-                }
-        expected_high = {
-                'USDT': (D("0.1226"), "long"),
-                'BTC':  (D("0.1429"), "long"),
-                'ETC':  (D("0.1127"), "long"),
-                'ETH':  (D("0.1569"), "long"),
-                'FCT':  (D("0.3341"), "long"),
-                'GAS':  (D("0.1308"), "long"),
+        self.assertEqual(portfolio.datetime(2018, 1, 15), market.Portfolio.last_date)
+
+    @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
+    def test_repartition(self, get_cryptoportfolio):
+        market.Portfolio.liquidities = {
+                "medium": {
+                    "2018-03-01": "medium_2018-03-01",
+                    "2018-03-08": "medium_2018-03-08",
+                    },
+                "high": {
+                    "2018-03-01": "high_2018-03-01",
+                    "2018-03-08": "high_2018-03-08",
+                    }

                 }
                 }

+        market.Portfolio.last_date = "2018-03-08"

 
 

-        self.assertEqual(expected_medium, portfolio.Portfolio.repartition(self.m))
-        self.assertEqual(expected_medium, portfolio.Portfolio.repartition(self.m, liquidity="medium"))
-        self.assertEqual(expected_high, portfolio.Portfolio.repartition(self.m, liquidity="high"))
-
-        self.assertEqual(1, self.wm.call_count)
-
-        portfolio.Portfolio.repartition(self.m)
-        self.assertEqual(1, self.wm.call_count)
-
-        portfolio.Portfolio.repartition(self.m, refetch=True)
-        self.assertEqual(2, self.wm.call_count)
-        self.m.report.log_http_request.assert_called()
-        self.assertEqual(2, self.m.report.log_http_request.call_count)
+        self.assertEqual("medium_2018-03-08", market.Portfolio.repartition())
+        get_cryptoportfolio.assert_called_once_with()
+        self.assertEqual("medium_2018-03-08", market.Portfolio.repartition(liquidity="medium"))
+        self.assertEqual("high_2018-03-08", market.Portfolio.repartition(liquidity="high"))

 
 

-    @mock.patch.object(portfolio.time, "sleep")
-    @mock.patch.object(portfolio.Portfolio, "repartition")
-    def test_wait_for_recent(self, repartition, sleep):
+    @mock.patch.object(market.time, "sleep")
+    @mock.patch.object(market.Portfolio, "get_cryptoportfolio")
+    def test_wait_for_recent(self, get_cryptoportfolio, sleep):

         self.call_count = 0
         self.call_count = 0

-        def _repartition(market, refetch):
-            self.assertEqual(self.m, market)
-            self.assertTrue(refetch)
+        def _get(refetch=False):
+            if self.call_count != 0:
+                self.assertTrue(refetch)
+            else:
+                self.assertFalse(refetch)

             self.call_count += 1
             self.call_count += 1

-            portfolio.Portfolio.last_date = portfolio.datetime.now()\
-                - portfolio.timedelta(10)\
-                + portfolio.timedelta(self.call_count)
-        repartition.side_effect = _repartition
+            market.Portfolio.last_date = store.datetime.now()\
+                - store.timedelta(10)\
+                + store.timedelta(self.call_count)
+        get_cryptoportfolio.side_effect = _get

 
 

-        portfolio.Portfolio.wait_for_recent(self.m)
+        market.Portfolio.wait_for_recent()

         sleep.assert_called_with(30)
         self.assertEqual(6, sleep.call_count)
         sleep.assert_called_with(30)
         self.assertEqual(6, sleep.call_count)

-        self.assertEqual(7, repartition.call_count)
-        self.m.report.print_log.assert_called_with("Attempt to fetch up-to-date cryptoportfolio")
+        self.assertEqual(7, get_cryptoportfolio.call_count)
+        market.Portfolio.report.print_log.assert_called_with("Attempt to fetch up-to-date cryptoportfolio")

 
         sleep.reset_mock()
 
         sleep.reset_mock()

-        repartition.reset_mock()
-        portfolio.Portfolio.last_date = None
+        get_cryptoportfolio.reset_mock()
+        market.Portfolio.last_date = None

         self.call_count = 0
         self.call_count = 0

-        portfolio.Portfolio.wait_for_recent(self.m, delta=15)
+        market.Portfolio.wait_for_recent(delta=15)

         sleep.assert_not_called()
         sleep.assert_not_called()

-        self.assertEqual(1, repartition.call_count)
+        self.assertEqual(1, get_cryptoportfolio.call_count)

 
         sleep.reset_mock()
 
         sleep.reset_mock()

-        repartition.reset_mock()
-        portfolio.Portfolio.last_date = None
+        get_cryptoportfolio.reset_mock()
+        market.Portfolio.last_date = None

         self.call_count = 0
         self.call_count = 0

-        portfolio.Portfolio.wait_for_recent(self.m, delta=1)
+        market.Portfolio.wait_for_recent(delta=1)

         sleep.assert_called_with(30)
         self.assertEqual(9, sleep.call_count)
         sleep.assert_called_with(30)
         self.assertEqual(9, sleep.call_count)

-        self.assertEqual(10, repartition.call_count)
+        self.assertEqual(10, get_cryptoportfolio.call_count)

 
 @unittest.skipUnless("unit" in limits, "Unit skipped")
 class AmountTest(WebMockTestCase):
 
 @unittest.skipUnless("unit" in limits, "Unit skipped")
 class AmountTest(WebMockTestCase):


@@ -1047,7 +1028,7 @@ class MarketTest(WebMockTestCase):
         self.assertEqual("Foo", m.fetch_fees())
         self.ccxt.fetch_fees.assert_not_called()
 
         self.assertEqual("Foo", m.fetch_fees())
         self.ccxt.fetch_fees.assert_not_called()
 

-    @mock.patch.object(portfolio.Portfolio, "repartition")
+    @mock.patch.object(market.Portfolio, "repartition")

     @mock.patch.object(market.Market, "get_ticker")
     @mock.patch.object(market.TradeStore, "compute_trades")
     def test_prepare_trades(self, compute_trades, get_ticker, repartition):
     @mock.patch.object(market.Market, "get_ticker")
     @mock.patch.object(market.TradeStore, "compute_trades")
     def test_prepare_trades(self, compute_trades, get_ticker, repartition):


@@ -1098,7 +1079,7 @@ class MarketTest(WebMockTestCase):
             m.report.log_balances.assert_called_once_with(tag="tag")
 
 
             m.report.log_balances.assert_called_once_with(tag="tag")
 
 

-    @mock.patch.object(portfolio.time, "sleep")
+    @mock.patch.object(market.time, "sleep")

     @mock.patch.object(market.TradeStore, "all_orders")
     def test_follow_orders(self, all_orders, time_mock):
         for debug, sleep in [
     @mock.patch.object(market.TradeStore, "all_orders")
     def test_follow_orders(self, all_orders, time_mock):
         for debug, sleep in [


@@ -1693,7 +1674,7 @@ class BalanceStoreTest(WebMockTestCase):
         self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
         self.m.report.log_balances.assert_called_with(tag="foo")
 
         self.assertListEqual(["USDT", "XVG", "XMR", "ETC"], list(balance_store.currencies()))
         self.m.report.log_balances.assert_called_with(tag="foo")
 

-    @mock.patch.object(portfolio.Portfolio, "repartition")
+    @mock.patch.object(market.Portfolio, "repartition")

     def test_dispatch_assets(self, repartition):
         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
 
     def test_dispatch_assets(self, repartition):
         self.m.ccxt.fetch_all_balances.return_value = self.fetch_balance
 


@@ -1710,7 +1691,7 @@ class BalanceStoreTest(WebMockTestCase):
         repartition.return_value = repartition_hash
 
         amounts = balance_store.dispatch_assets(portfolio.Amount("BTC", "11.1"))
         repartition.return_value = repartition_hash
 
         amounts = balance_store.dispatch_assets(portfolio.Amount("BTC", "11.1"))

-        repartition.assert_called_with(self.m, liquidity="medium")
+        repartition.assert_called_with(liquidity="medium")

         self.assertIn("XEM", balance_store.currencies())
         self.assertEqual(D("2.6"), amounts["BTC"].value)
         self.assertEqual(D("7.5"), amounts["XEM"].value)
         self.assertIn("XEM", balance_store.currencies())
         self.assertEqual(D("2.6"), amounts["BTC"].value)
         self.assertEqual(D("7.5"), amounts["XEM"].value)


@@ -3505,7 +3486,7 @@ class ProcessorTest(WebMockTestCase):
 
             processor.run_action("wait_for_recent", "bar", "baz")
 
 
             processor.run_action("wait_for_recent", "bar", "baz")
 

-            method_mock.assert_called_with(self.m, foo="bar")
+            method_mock.assert_called_with(foo="bar")

 
     def test_select_step(self):
         processor = market.Processor(self.m)
 
     def test_select_step(self):
         processor = market.Processor(self.m)


@@ -3547,7 +3528,7 @@ class ProcessorTest(WebMockTestCase):
         processor = market.Processor(m)
 
         method, arguments = processor.method_arguments("wait_for_recent")
         processor = market.Processor(m)
 
         method, arguments = processor.method_arguments("wait_for_recent")

-        self.assertEqual(portfolio.Portfolio.wait_for_recent, method)
+        self.assertEqual(market.Portfolio.wait_for_recent, method)

         self.assertEqual(["delta"], arguments)
 
         method, arguments = processor.method_arguments("prepare_trades")
         self.assertEqual(["delta"], arguments)
 
         method, arguments = processor.method_arguments("prepare_trades")


@@ -3730,7 +3711,7 @@ class AcceptanceTest(WebMockTestCase):
         market = mock.Mock()
         market.fetch_all_balances.return_value = fetch_balance
         market.fetch_ticker.side_effect = fetch_ticker
         market = mock.Mock()
         market.fetch_all_balances.return_value = fetch_balance
         market.fetch_ticker.side_effect = fetch_ticker

-        with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
+        with mock.patch.object(market.Portfolio, "repartition", return_value=repartition):

             # Action 1
             helper.prepare_trades(market)
 
             # Action 1
             helper.prepare_trades(market)
 


@@ -3809,7 +3790,7 @@ class AcceptanceTest(WebMockTestCase):
                     "amount": "10", "total": "1"
                     }
                 ]
                     "amount": "10", "total": "1"
                     }
                 ]

-        with mock.patch.object(portfolio.time, "sleep") as sleep:
+        with mock.patch.object(market.time, "sleep") as sleep:

             # Action 4
             helper.follow_orders(verbose=False)
 
             # Action 4
             helper.follow_orders(verbose=False)
 


@@ -3850,7 +3831,7 @@ class AcceptanceTest(WebMockTestCase):
                 }
         market.fetch_all_balances.return_value = fetch_balance
 
                 }
         market.fetch_all_balances.return_value = fetch_balance
 

-        with mock.patch.object(portfolio.Portfolio, "repartition", return_value=repartition):
+        with mock.patch.object(market.Portfolio, "repartition", return_value=repartition):

             # Action 5
             helper.prepare_trades(market, only="acquire", compute_value="average")
 
             # Action 5
             helper.prepare_trades(market, only="acquire", compute_value="average")
 


@@ -3922,7 +3903,7 @@ class AcceptanceTest(WebMockTestCase):
         # TODO
         # portfolio.TradeStore.run_orders()
 
         # TODO
         # portfolio.TradeStore.run_orders()
 

-        with mock.patch.object(portfolio.time, "sleep") as sleep:
+        with mock.patch.object(market.time, "sleep") as sleep:

             # Action 8
             helper.follow_orders(verbose=False)
 
             # Action 8
             helper.follow_orders(verbose=False)