remove nose and mock dependencies, replace nose approx with pytest approx, autoformat bench

timkpaine · timkpaine · commit 613b1aa8e9a3 · 2022-07-01T10:40:03.000-04:00
diff --git a/bt/algos.py b/bt/algos.py
@@ -10,7 +10,6 @@
 import numpy as np
 import pandas as pd
 import sklearn.covariance
-from future.utils import iteritems
 
 import bt
 from bt.core import Algo, AlgoStack, SecurityBase, is_zero
@@ -1060,7 +1059,7 @@ def __init__(self, scale):
 
     def __call__(self, target):
         target.temp["weights"] = {
-            k: self.scale * w for k, w in iteritems(target.temp["weights"])
+            k: self.scale * w for k, w in target.temp["weights"].items()
         }
         return True
 
@@ -1809,7 +1808,7 @@ def __call__(self, target):
             base = base * (1 - target.temp["cash"])
 
         # Turn off updating while we rebalance each child
-        for item in iteritems(targets):
+        for item in targets.items():
             target.rebalance(item[1], child=item[0], base=base, update=False)
 
         # Now update
@@ -2054,7 +2053,7 @@ def __call__(self, target):
         # Find securities that are candidate for closing
         sec_names = [
             sec_name
-            for sec_name, sec in iteritems(target.children)
+            for sec_name, sec in target.children.items()
             if isinstance(sec, SecurityBase)
             and sec_name in close_dates.index
             and sec_name not in target.perm["closed"]
@@ -2108,7 +2107,7 @@ def __call__(self, target):
         # Find securities that are candidate for roll
         sec_names = [
             sec_name
-            for sec_name, sec in iteritems(target.children)
+            for sec_name, sec in target.children.items()
             if isinstance(sec, SecurityBase)
             and sec_name in roll_data.index
             and sec_name not in target.perm["rolled"]
@@ -2127,7 +2126,7 @@ def __call__(self, target):
                 target.close(sec_name, update=False)
 
         # Do all the new transactions at the end, to do any necessary aggregations first
-        for new_sec, quantity in iteritems(transactions):
+        for new_sec, quantity in transactions.items():
             target.transact(quantity, new_sec, update=False)
 
         # Now update
diff --git a/bt/core.py b/bt/core.py
@@ -9,7 +9,6 @@
 import cython as cy
 import numpy as np
 import pandas as pd
-from future.utils import iteritems
 
 
 PAR = 100.0
@@ -147,7 +146,7 @@ def _add_children(self, children, dc):
             if isinstance(children, dict):
                 # Preserve the names from the dictionary by renaming the nodes
                 tmp = []
-                for name, c in iteritems(children):
+                for name, c in children.items():
                     if isinstance(c, str):
                         tmp.append(name)
                     else:
diff --git a/setup.py b/setup.py
@@ -48,9 +48,7 @@ def local_file(filename):
             "ffn>=0.3.5",
             "flake8",
             "flake8-black",
-            "future",
             "matplotlib>=2",
-            "mock",
             "numpy>=1",
             "pandas>=0.19",
             "pyprind>=2.11",
diff --git a/tests/bench.py b/tests/bench.py
@@ -9,65 +9,79 @@
 
 def benchmark_1():
     x = np.random.randn(10000, 1000) * 0.01
-    idx = pd.date_range('1990-01-01', freq='B', periods=x.shape[0])
+    idx = pd.date_range("1990-01-01", freq="B", periods=x.shape[0])
     data = np.exp(pd.DataFrame(x, index=idx).cumsum())
 
-    s = bt.Strategy('s', [bt.algos.RunMonthly(),
-                          bt.algos.SelectRandomly(len(data.columns) / 2),
-                          bt.algos.WeighRandomly(),
-                          bt.algos.Rebalance()])
+    s = bt.Strategy(
+        "s",
+        [
+            bt.algos.RunMonthly(),
+            bt.algos.SelectRandomly(len(data.columns) / 2),
+            bt.algos.WeighRandomly(),
+            bt.algos.Rebalance(),
+        ],
+    )
 
     t = bt.Backtest(s, data)
     return bt.run(t)
-    
+
+
 def benchmark_2():
     x = np.random.randn(10000, 1000) * 0.01
-    idx = pd.date_range('1990-01-01', freq='B', periods=x.shape[0])
+    idx = pd.date_range("1990-01-01", freq="B", periods=x.shape[0])
     data = np.exp(pd.DataFrame(x, index=idx).cumsum())
     bidoffer = data * 0.01
-    coupons = data * 0.
-    s = bt.FixedIncomeStrategy('s', 
-                            algos = [bt.algos.RunMonthly(),
-                              bt.algos.SelectRandomly(len(data.columns) / 2),
-                              bt.algos.WeighRandomly(),
-                              bt.algos.Rebalance()],
-                              children = [ bt.CouponPayingSecurity(c) 
-                                            for c in data ]
-                              )
+    coupons = data * 0.0
+    s = bt.FixedIncomeStrategy(
+        "s",
+        algos=[
+            bt.algos.RunMonthly(),
+            bt.algos.SelectRandomly(len(data.columns) / 2),
+            bt.algos.WeighRandomly(),
+            bt.algos.Rebalance(),
+        ],
+        children=[bt.CouponPayingSecurity(c) for c in data],
+    )
 
-    t = bt.Backtest(s, data, additional_data = {'bidoffer':bidoffer, 
-                                                'coupons':coupons})
+    t = bt.Backtest(s, data, additional_data={"bidoffer": bidoffer, "coupons": coupons})
     return bt.run(t)
 
+
 def benchmark_3():
     # Similar to benchmark_1, but with trading in only a small subset of assets
     # However, because the "multipier" is used, we can't just pass the string
     # names to the constructor, and so the solution is to use the lazy_add flag.
     # Changing lazy_add to False demonstrates the performance gain.
     # i.e. on Win32, it went from 4.3s with the flag to 10.9s without.
-    
+
     x = np.random.randn(10000, 1000) * 0.01
-    idx = pd.date_range('1990-01-01', freq='B', periods=x.shape[0])
+    idx = pd.date_range("1990-01-01", freq="B", periods=x.shape[0])
     data = np.exp(pd.DataFrame(x, index=idx).cumsum())
-    children = [ bt.Security(name=i, multiplier=10, lazy_add=False) 
-                for i in range(1000) ]
-    s = bt.Strategy('s', [bt.algos.RunMonthly(),
-                          bt.algos.SelectThese([0,1]),
-                          bt.algos.WeighRandomly(),
-                          bt.algos.Rebalance()], children = children)
+    children = [bt.Security(name=i, multiplier=10, lazy_add=False) for i in range(1000)]
+    s = bt.Strategy(
+        "s",
+        [
+            bt.algos.RunMonthly(),
+            bt.algos.SelectThese([0, 1]),
+            bt.algos.WeighRandomly(),
+            bt.algos.Rebalance(),
+        ],
+        children=children,
+    )
 
     t = bt.Backtest(s, data)
     return bt.run(t)
-    
-if __name__ == '__main__':
-    print('\n\n\n================= Benchmark 1 =======================\n')
-    cProfile.run('benchmark_1()', sort='tottime')
-    print('\n----------------- Benchmark 1 -----------------------\n\n\n')
-    
-    print('\n\n\n================= Benchmark 2 =======================\n')
-    cProfile.run('benchmark_2()', sort='tottime')
-    print('\n----------------- Benchmark 2 -----------------------\n\n\n')
-    
-    print('\n\n\n================= Benchmark 3 =======================\n')
-    cProfile.run('benchmark_3()', sort='cumtime')
-    print('\n----------------- Benchmark 3 -----------------------\n\n\n')
+
+
+if __name__ == "__main__":
+    print("\n\n\n================= Benchmark 1 =======================\n")
+    cProfile.run("benchmark_1()", sort="tottime")
+    print("\n----------------- Benchmark 1 -----------------------\n\n\n")
+
+    print("\n\n\n================= Benchmark 2 =======================\n")
+    cProfile.run("benchmark_2()", sort="tottime")
+    print("\n----------------- Benchmark 2 -----------------------\n\n\n")
+
+    print("\n\n\n================= Benchmark 3 =======================\n")
+    cProfile.run("benchmark_3()", sort="cumtime")
+    print("\n----------------- Benchmark 3 -----------------------\n\n\n")
diff --git a/tests/test_algos.py b/tests/test_algos.py
@@ -1,17 +1,11 @@
 from __future__ import division
 from datetime import datetime
+from unittest import mock
 
-import sys
-if sys.version_info < (3, 3):
-    import mock
-else:
-    from unittest import mock
-
-
-import pandas as pd
 import numpy as np
+import pandas as pd
+import pytest
 import random
-from nose.tools import assert_almost_equal as aae
 
 import bt
 import bt.algos as algos
@@ -1284,8 +1278,8 @@ def test_weigh_inv_vol():
     weights = s.temp['weights']
     assert len(weights) == 2
     assert weights['c2'] > weights['c1']
-    aae(weights['c1'], 0.020, 3)
-    aae(weights['c2'], 0.980, 3)
+    assert weights['c1'] == pytest.approx(0.020, 3)
+    assert weights['c2'] == pytest.approx(0.980, 3)
 
 
 @mock.patch('ffn.calc_mean_var_weights')
@@ -1330,7 +1324,7 @@ def test_weigh_randomly():
     assert algo(s)
     weights = s.temp['weights']
     assert len( weights ) == 3
-    aae( sum( weights.values() ), 0.95 )
+    assert sum( weights.values()) == pytest.approx(0.95)
     for c in s.temp['selected']:
         assert weights[c] <= 0.5
         assert weights[c] >= 0.3
@@ -2187,11 +2181,11 @@ def test_hedge_risk():
 
     # Check that risk is hedged!
     assert s.risk['Risk1'] == 0
-    aae( s.risk['Risk2'], 0, 13)
+    assert s.risk['Risk2'] == pytest.approx(0, 13)
     # Check that positions are nonzero (trivial solution)
     assert c1.position == 100
     assert c2.position == -10
-    aae( c3.position, -(100*2 - 10*5)/10., 13)
+    assert c3.position == pytest.approx(-(100*2 - 10*5)/10., 13)
     
   
 def test_hedge_risk_nan():
diff --git a/tests/test_backtest.py b/tests/test_backtest.py
@@ -1,14 +1,13 @@
 from __future__ import division
-import bt
-import pandas as pd
+
 import numpy as np
-from nose.tools import assert_almost_equal as aae
+import pandas as pd
+import pytest
 import random
-import sys
-if sys.version_info < (3, 3):
-    import mock
-else:
-    from unittest import mock
+
+from unittest import mock
+
+import bt
 
 
 def test_backtest_copies_strategy():
@@ -325,7 +324,7 @@ def test_RenomalizedFixedIncomeResult():
     
     # Renormalizing results to a constant size "fixes" this
     norm_res = bt.backtest.RenormalizedFixedIncomeResult( 1e6, *res.backtest_list )    
-    aae( norm_res.stats['s'].total_return, t.strategy.value / 1e6, 16 )
+    assert norm_res.stats['s'].total_return == pytest.approx(t.strategy.value / 1e6, 16)
     
     # Check that using the lagged notional value series leads to the same results
     # as the original calculation. This proves that we can re-derive the price
diff --git a/tests/test_core.py b/tests/test_core.py
