taxcalc 4.3.5__py3-none-any.whl → 4.4.1__py3-none-any.whl

taxcalc/tests/test_decorators.py

@@ -1,18 +1,28 @@
+"""
+Test decorators.
+"""
 # CODING-STYLE CHECKS:
 # pycodestyle test_decorators.py
+# pylint --disable=locally-disabled test_decorators.py
 
 import os
-import sys
-import pytest
 import importlib
 import numpy as np
 from pandas import DataFrame
 from pandas.testing import assert_frame_equal
+import pytest
 import taxcalc
-from taxcalc.decorators import *
+from taxcalc.decorators import (
+    iterate_jit,
+    apply_jit,
+    create_apply_function_string,
+    create_toplevel_function_string,
+    make_apply_function,
+)
 
 
 def test_create_apply_function_string():
+    """Test docstring"""
     ans = create_apply_function_string(['a', 'b', 'c'], ['d', 'e'], [])
     exp = ("def ap_func(x_0,x_1,x_2,x_3,x_4):\n"
            "  for i in range(len(x_0)):\n"
@@ -22,6 +32,7 @@ def test_create_apply_function_string():
 
 
 def test_create_apply_function_string_with_params():
+    """Test docstring"""
     ans = create_apply_function_string(['a', 'b', 'c'], ['d', 'e'], ['d'])
     exp = ("def ap_func(x_0,x_1,x_2,x_3,x_4):\n"
            "  for i in range(len(x_0)):\n"
@@ -31,6 +42,7 @@ def test_create_apply_function_string_with_params():
 
 
 def test_create_toplevel_function_string_mult_outputs():
+    """Test docstring"""
     ans = create_toplevel_function_string(['a', 'b'], ['d', 'e'],
                                           ['pm', 'pm', 'pf', 'pm'])
     exp = ''
@@ -55,6 +67,7 @@ def test_create_toplevel_function_string_mult_outputs():
 
 
 def test_create_toplevel_function_string():
+    """Test docstring"""
     ans = create_toplevel_function_string(['a'], ['d', 'e'],
                                           ['pm', 'pf', 'pm'])
     exp = ''
@@ -78,12 +91,14 @@ def test_create_toplevel_function_string():
 
 
 def some_calc(x, y, z):
+    """Function docstring"""
     a = x + y
     b = x + y + z
     return (a, b)
 
 
 def test_make_apply_function():
+    """Test docstring"""
     ans_do_jit = make_apply_function(some_calc, ['a', 'b'], ['x', 'y', 'z'],
                                      [], do_jit=True, no_python=True)
     assert ans_do_jit
@@ -93,33 +108,45 @@ def test_make_apply_function():
 
 
 @apply_jit(["a", "b"], ["x", "y", "z"], nopython=True)
-def Magic_calc(x, y, z):
+def magic_calc(x, y, z):
+    """Function docstring"""
     a = x + y
     b = x + y + z
     return (a, b)
 
 
-def Magic(pm, pf):
+def magic(pm, pf):
+    """Function docstring"""
     # Adjustments
-    outputs = pf.a, pf.b = Magic_calc(pm, pf)
+    # pylint: disable=no-value-for-parameter
+    outputs = pf.a, pf.b = magic_calc(pm, pf)
+    # pylint: enable=no-value-for-parameter
     header = ['a', 'b']
     return DataFrame(data=np.column_stack(outputs), columns=header)
 
 
 @iterate_jit(nopython=True)
-def Magic_calc2(x, y, z):
+def magic_calc2(x, y, z):
+    """Function docstring"""
     a = x + y
     b = x + y + z
     return (a, b)
 
 
-class Foo(object):
-    pass
+class Foo:  # pylint: disable=too-many-instance-attributes
+    """Foo class"""
+
+    def faux_method1(self):
+        """ Foo method"""
+
+    def faux_method2(self):
+        """ Foo method"""
 
 
 @iterate_jit(nopython=True)
-def faux_function(MARS):
-    if MARS == 1:
+def faux_function(mars):
+    """Function docstring"""
+    if mars == 1:
         var = 2
     else:
         var = 1
@@ -128,17 +155,21 @@ def faux_function(MARS):
 
 @iterate_jit(nopython=True)
 def ret_everything(a, b, c, d, e, f):
-
+    """Function docstring"""
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     c = a + b
     d = a + b
     e = a + b
     f = a + b
-
     return (c, d, e,
             f)
 
 
+# pylint: disable=attribute-defined-outside-init
+
+
 def test_magic_apply_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((5,))
@@ -146,12 +177,13 @@ def test_magic_apply_jit():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    xx = Magic(pm, pf)
+    xx = magic(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
     assert_frame_equal(xx, exp)
 
 
 def test_magic_apply_jit_swap():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((5,))
@@ -159,12 +191,16 @@ def test_magic_apply_jit_swap():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    xx = Magic(pf, pm)
+    xx = magic(pf, pm)  # pylint: disable=arguments-out-of-order
     exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
     assert_frame_equal(xx, exp)
 
 
+# pylint: disable=no-value-for-parameter
+
+
 def test_magic_iterate_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -172,22 +208,24 @@ def test_magic_iterate_jit():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    xx = Magic_calc2(pm, pf)
+    xx = magic_calc2(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
     assert_frame_equal(xx, exp)
 
 
 def test_faux_function_iterate_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
-    pf.MARS = np.ones((5,))
+    pf.mars = np.ones((5,))
     pf.var = np.ones((5,))
-    ans = faux_function(pm, pf)
+    ans = faux_function(pm, pf)  # pylint: disable=too-many-function-args
     exp = DataFrame(data=[2.0] * 5, columns=['var'])
     assert_frame_equal(ans, exp)
 
 
 def test_ret_everything_iterate_jit():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pf.a = np.ones((5,))
@@ -203,13 +241,15 @@ def test_ret_everything_iterate_jit():
 
 
 @iterate_jit(nopython=True)
-def Magic_calc3(x, y, z):
+def magic_calc3(x, y, z):
+    """Function docstring"""
     a = x + y
     b = a + z
     return (a, b)
 
 
 def test_function_takes_kwarg():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -217,20 +257,22 @@ def test_function_takes_kwarg():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc3(pm, pf)
+    ans = magic_calc3(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)
 
 
 @iterate_jit(nopython=True)
-def Magic_calc4(x, y, z):
+def magic_calc4(x, y, z):
+    """Function docstring"""
     a = x + y
     b = a + z
     return (a, b)
 
 
 def test_function_no_parameters_listed():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -238,20 +280,22 @@ def test_function_no_parameters_listed():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc4(pm, pf)
+    ans = magic_calc4(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)
 
 
 @iterate_jit(parameters=['w'], nopython=True)
-def Magic_calc5(w, x, y, z):
+def magic_calc5(w, x, y, z):
+    """Function docstring"""
     a = x + y
     b = w[0] + x + y + z
     return (a, b)
 
 
 def test_function_parameters_optional():
+    """Test docstring"""
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -260,30 +304,37 @@ def test_function_parameters_optional():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc5(pm, pf)
+    ans = magic_calc5(pm, pf)
     exp = DataFrame(data=[[2.0, 4.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)
 
 
+# pylint: enable=no-value-for-parameter
+
+
 def unjittable_function1(w, x, y, z):
-    a = x + y
-    b = w[0] + x + y + z
+    """Function docstring"""
+    a = x + y  # pylint: disable=unused-variable
+    b = w[0] + x + y + z  # pylint: disable=unused-variable
 
 
 def unjittable_function2(w, x, y, z):
+    """Function docstring"""
     a = x + y
     b = w[0] + x + y + z
-    return (a, b, c)
+    return (a, b, c)  # pylint: disable=undefined-variable
 
 
 def test_iterate_jit_raises_on_no_return():
+    """Test docstring"""
     with pytest.raises(ValueError):
         ij = iterate_jit(parameters=['w'], nopython=True)
         ij(unjittable_function1)
 
 
 def test_iterate_jit_raises_on_unknown_return_argument():
+    """Test docstring"""
     ij = iterate_jit(parameters=['w'], nopython=True)
     uf2 = ij(unjittable_function2)
     pm = Foo()
@@ -295,10 +346,11 @@ def test_iterate_jit_raises_on_unknown_return_argument():
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
     with pytest.raises(AttributeError):
-        ans = uf2(pm, pf)
+        ans = uf2(pm, pf)  # pylint: disable=unused-variable
 
 
-def Magic_calc6(w, x, y, z):
+def magic_calc6(w, x, y, z):
+    """Function docstring"""
     a = x + y
     b = w[0] + x + y + z
     return (a, b)
@@ -313,8 +365,8 @@ def test_force_no_jit():
     os.environ['NOTAXCALCJIT'] = 'NOJIT'
     # reload the decorators module
     importlib.reload(taxcalc.decorators)
-    # verify Magic_calc6 function works as expected
-    Magic_calc6_ = iterate_jit(parameters=['w'], nopython=True)(Magic_calc6)
+    # verify magic_calc6 function works as expected
+    magic_calc6_ = iterate_jit(parameters=['w'], nopython=True)(magic_calc6)
     pm = Foo()
     pf = Foo()
     pm.a = np.ones((1, 5))
@@ -323,7 +375,7 @@ def test_force_no_jit():
     pf.x = np.ones((5,))
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
-    ans = Magic_calc6_(pm, pf)
+    ans = magic_calc6_(pm, pf)
     exp = DataFrame(data=[[2.0, 4.0]] * 5,
                     columns=["a", "b"])
     assert_frame_equal(ans, exp)

taxcalc/tests/test_growdiff.py

@@ -1,19 +1,23 @@
+"""
+Test GrowDiff class and its methods.
+"""
 # CODING-STYLE CHECKS:
 # pycodestyle test_growdiff.py
+# pylint --disable=locally-disabled test_growdiff.py
 
 import os
 import json
 import numpy as np
-import pytest
 from taxcalc import GrowDiff, GrowFactors, Policy
 
 
-def test_year_consistency():
+def test_start_year_consistency():
+    """Test docstring"""
     assert GrowDiff.JSON_START_YEAR == Policy.JSON_START_YEAR
-    assert GrowDiff.DEFAULT_NUM_YEARS == Policy.DEFAULT_NUM_YEARS
 
 
 def test_update_and_apply_growdiff():
+    """Test docstring"""
     gdiff = GrowDiff()
     # update GrowDiff instance
     diffs = {
@@ -21,28 +25,29 @@ def test_update_and_apply_growdiff():
                   2016: 0.02}
     }
     gdiff.update_growdiff(diffs)
-    expected_wage_diffs = [0.00, 0.01, 0.01, 0.02, 0.02]
-    extra_years = GrowDiff.DEFAULT_NUM_YEARS - len(expected_wage_diffs)
-    expected_wage_diffs.extend([0.02] * extra_years)
-    assert np.allclose(gdiff._AWAGE, expected_wage_diffs, atol=0.0, rtol=0.0)
+    exp_wage_diffs = [0.00, 0.01, 0.01, 0.02, 0.02]
+    extra_years = gdiff.num_years - len(exp_wage_diffs)
+    exp_wage_diffs.extend([0.02] * extra_years)
+    act_wage_diffs = gdiff._AWAGE  # pylint: disable=protected-access
+    assert np.allclose(act_wage_diffs, exp_wage_diffs, atol=0.0, rtol=0.0)
     # apply growdiff to GrowFactors instance
     gf = GrowFactors()
-    syr = GrowDiff.JSON_START_YEAR
-    nyrs = GrowDiff.DEFAULT_NUM_YEARS
-    lyr = syr + nyrs - 1
+    syr = gdiff.start_year
+    lyr = gdiff.end_year
     pir_pre = gf.price_inflation_rates(syr, lyr)
     wgr_pre = gf.wage_growth_rates(syr, lyr)
     gfactors = GrowFactors()
     gdiff.apply_to(gfactors)
     pir_pst = gfactors.price_inflation_rates(syr, lyr)
     wgr_pst = gfactors.wage_growth_rates(syr, lyr)
-    expected_wgr_pst = [wgr_pre[i] + expected_wage_diffs[i]
-                        for i in range(0, nyrs)]
+    expected_wgr_pst = [wgr_pre[i] + exp_wage_diffs[i]
+                        for i in range(0, gdiff.num_years)]
     assert np.allclose(pir_pre, pir_pst, atol=0.0, rtol=0.0)
     assert np.allclose(wgr_pst, expected_wgr_pst, atol=1.0e-9, rtol=0.0)
 
 
 def test_has_any_response():
+    """Test docstring"""
     start_year = GrowDiff.JSON_START_YEAR
     gdiff = GrowDiff()
     assert gdiff.current_year == start_year
@@ -58,7 +63,7 @@ def test_description_punctuation(tests_path):
     """
     # read JSON file into a dictionary
     path = os.path.join(tests_path, '..', 'growdiff.json')
-    with open(path, 'r') as jsonfile:
+    with open(path, 'r', encoding='utf-8') as jsonfile:
         dct = json.load(jsonfile)
     all_desc_ok = True
     for param in dct.keys():
@@ -78,7 +83,7 @@ def test_boolean_value_infomation(tests_path):
     """
     # read growdiff.json file into a dictionary
     path = os.path.join(tests_path, '..', 'growdiff.json')
-    with open(path, 'r') as gddfile:
+    with open(path, 'r', encoding='utf-8') as gddfile:
         gdd = json.load(gddfile)
     for param in gdd.keys():
         if param == "schema":
@@ -88,11 +93,7 @@ def test_boolean_value_infomation(tests_path):
             val = val[0]
             if isinstance(val, list):
                 val = val[0]
-        valstr = str(val)
-        if valstr == 'True' or valstr == 'False':
-            val_is_boolean = True
-        else:
-            val_is_boolean = False
+        val_is_boolean = str(val) in ('True', 'False')
         type_is_boolean = gdd[param]['type'] == 'bool'
         if val_is_boolean and not type_is_boolean:
             print('param,value_type,val,val_is_boolean=',

taxcalc/tests/test_growfactors.py

@@ -8,8 +8,9 @@ Tests of Tax-Calculator GrowFactors class.
 import os
 import tempfile
 import pytest
-# pylint: disable=import-error
-from taxcalc import GrowFactors, Records, Policy
+from taxcalc.growfactors import GrowFactors
+from taxcalc.policy import Policy
+from taxcalc.records import Records
 
 
 @pytest.fixture(scope='module', name='bad_gf_file')
@@ -17,11 +18,10 @@ def fixture_bad_gf_file():
     """
     Fixture for invalid growfactors file.
     """
-    txt = (u'YEAR,AWAGE,ACPIU,ABADNAME,ASOCSEC\n'
-           u'2015,1.000,1.000,1.000000,1.00000\n')
-    tfile = tempfile.NamedTemporaryFile(mode='a', delete=False)
-    tfile.write(txt)
-    tfile.close()
+    txt = ('YEAR,AWAGE,ACPIU,ABADNAME,ASOCSEC\n'
+           '2015,1.000,1.000,1.000000,1.00000\n')
+    with tempfile.NamedTemporaryFile(mode='a', delete=False) as tfile:
+        tfile.write(txt)
     yield tfile
     os.remove(tfile.name)
 
@@ -31,7 +31,7 @@ def test_improper_usage(bad_gf_file):
     Tests of improper usage of GrowFactors object.
     """
     with pytest.raises(ValueError):
-        gfo = GrowFactors(dict())
+        gfo = GrowFactors({})
     with pytest.raises(ValueError):
         gfo = GrowFactors('non_existent_file.csv')
     with pytest.raises(ValueError):