taxcalc 4.2.1__py3-none-any.whl → 4.3.0__py3-none-any.whl

taxcalc/tests/test_decorators.py

@@ -0,0 +1,332 @@
+# CODING-STYLE CHECKS:
+# pycodestyle 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 taxcalc
+from taxcalc.decorators import *
+
+
+def test_create_apply_function_string():
+    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"
+           "    x_0[i],x_1[i],x_2[i] = jitted_f(x_3[i],x_4[i])\n"
+           "  return x_0,x_1,x_2\n")
+    assert ans == exp
+
+
+def test_create_apply_function_string_with_params():
+    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"
+           "    x_0[i],x_1[i],x_2[i] = jitted_f(x_3,x_4[i])\n"
+           "  return x_0,x_1,x_2\n")
+    assert ans == exp
+
+
+def test_create_toplevel_function_string_mult_outputs():
+    ans = create_toplevel_function_string(['a', 'b'], ['d', 'e'],
+                                          ['pm', 'pm', 'pf', 'pm'])
+    exp = ''
+    exp = ("def hl_func(pm, pf):\n"
+           "    from pandas import DataFrame\n"
+           "    import numpy as np\n"
+           "    import pandas as pd\n"
+           "    def get_values(x):\n"
+           "        if isinstance(x, pd.Series):\n"
+           "            return x.values\n"
+           "        else:\n"
+           "            return x\n"
+           "    outputs = \\\n"
+           "        (pm.a, pm.b) = \\\n"
+           "        applied_f(get_values(pm.a[0]), get_values(pm.b[0]), "
+           "get_values(pf.d), get_values(pm.e[0]), )\n"
+           "    header = ['a', 'b']\n"
+           "    return DataFrame(data=np.column_stack(outputs),"
+           "columns=header)")
+
+    assert ans == exp
+
+
+def test_create_toplevel_function_string():
+    ans = create_toplevel_function_string(['a'], ['d', 'e'],
+                                          ['pm', 'pf', 'pm'])
+    exp = ''
+    exp = ("def hl_func(pm, pf):\n"
+           "    from pandas import DataFrame\n"
+           "    import numpy as np\n"
+           "    import pandas as pd\n"
+           "    def get_values(x):\n"
+           "        if isinstance(x, pd.Series):\n"
+           "            return x.values\n"
+           "        else:\n"
+           "            return x\n"
+           "    outputs = \\\n"
+           "        (pm.a) = \\\n"
+           "        applied_f(get_values(pm.a[0]), get_values(pf.d), "
+           "get_values(pm.e[0]), )\n"
+           "    header = ['a']\n"
+           "    return DataFrame(data=outputs,"
+           "columns=header)")
+    assert ans == exp
+
+
+def some_calc(x, y, z):
+    a = x + y
+    b = x + y + z
+    return (a, b)
+
+
+def test_make_apply_function():
+    ans_do_jit = make_apply_function(some_calc, ['a', 'b'], ['x', 'y', 'z'],
+                                     [], do_jit=True, no_python=True)
+    assert ans_do_jit
+    ans_no_jit = make_apply_function(some_calc, ['a', 'b'], ['x', 'y', 'z'],
+                                     [], do_jit=False, no_python=True)
+    assert ans_no_jit
+
+
+@apply_jit(["a", "b"], ["x", "y", "z"], nopython=True)
+def Magic_calc(x, y, z):
+    a = x + y
+    b = x + y + z
+    return (a, b)
+
+
+def Magic(pm, pf):
+    # Adjustments
+    outputs = pf.a, pf.b = Magic_calc(pm, pf)
+    header = ['a', 'b']
+    return DataFrame(data=np.column_stack(outputs), columns=header)
+
+
+@iterate_jit(nopython=True)
+def Magic_calc2(x, y, z):
+    a = x + y
+    b = x + y + z
+    return (a, b)
+
+
+class Foo(object):
+    pass
+
+
+@iterate_jit(nopython=True)
+def faux_function(MARS):
+    if MARS == 1:
+        var = 2
+    else:
+        var = 1
+    return var
+
+
+@iterate_jit(nopython=True)
+def ret_everything(a, b, c, d, e, f):
+
+    c = a + b
+    d = a + b
+    e = a + b
+    f = a + b
+
+    return (c, d, e,
+            f)
+
+
+def test_magic_apply_jit():
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((5,))
+    pm.b = np.ones((5,))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    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():
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((5,))
+    pm.b = np.ones((5,))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    xx = Magic(pf, pm)
+    exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
+    assert_frame_equal(xx, exp)
+
+
+def test_magic_iterate_jit():
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((1, 5))
+    pm.b = np.ones((1, 5))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    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():
+    pm = Foo()
+    pf = Foo()
+    pf.MARS = np.ones((5,))
+    pf.var = np.ones((5,))
+    ans = faux_function(pm, pf)
+    exp = DataFrame(data=[2.0] * 5, columns=['var'])
+    assert_frame_equal(ans, exp)
+
+
+def test_ret_everything_iterate_jit():
+    pm = Foo()
+    pf = Foo()
+    pf.a = np.ones((5,))
+    pf.b = np.ones((5,))
+    pf.c = np.ones((5,))
+    pf.d = np.ones((5,))
+    pf.e = np.ones((5,))
+    pf.f = np.ones((5,))
+    ans = ret_everything(pm, pf)
+    exp = DataFrame(data=[[2.0, 2.0, 2.0, 2.0]] * 5,
+                    columns=["c", "d", "e", "f"])
+    assert_frame_equal(ans, exp)
+
+
+@iterate_jit(nopython=True)
+def Magic_calc3(x, y, z):
+    a = x + y
+    b = a + z
+    return (a, b)
+
+
+def test_function_takes_kwarg():
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((1, 5))
+    pm.b = np.ones((1, 5))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    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):
+    a = x + y
+    b = a + z
+    return (a, b)
+
+
+def test_function_no_parameters_listed():
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((1, 5))
+    pm.b = np.ones((1, 5))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    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):
+    a = x + y
+    b = w[0] + x + y + z
+    return (a, b)
+
+
+def test_function_parameters_optional():
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((1, 5))
+    pm.b = np.ones((1, 5))
+    pm.w = np.ones((1, 5))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    ans = Magic_calc5(pm, pf)
+    exp = DataFrame(data=[[2.0, 4.0]] * 5,
+                    columns=["a", "b"])
+    assert_frame_equal(ans, exp)
+
+
+def unjittable_function1(w, x, y, z):
+    a = x + y
+    b = w[0] + x + y + z
+
+
+def unjittable_function2(w, x, y, z):
+    a = x + y
+    b = w[0] + x + y + z
+    return (a, b, c)
+
+
+def test_iterate_jit_raises_on_no_return():
+    with pytest.raises(ValueError):
+        ij = iterate_jit(parameters=['w'], nopython=True)
+        ij(unjittable_function1)
+
+
+def test_iterate_jit_raises_on_unknown_return_argument():
+    ij = iterate_jit(parameters=['w'], nopython=True)
+    uf2 = ij(unjittable_function2)
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((1, 5))
+    pm.b = np.ones((1, 5))
+    pm.w = np.ones((1, 5))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    with pytest.raises(AttributeError):
+        ans = uf2(pm, pf)
+
+
+def Magic_calc6(w, x, y, z):
+    a = x + y
+    b = w[0] + x + y + z
+    return (a, b)
+
+
+def test_force_no_jit():
+    """
+    Force execution of code for "DO_JIT = False", which tests the
+    id_wrapper function in the decorators.py file.
+    """
+    # set environment variable that turns off JIT decorator logic
+    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)
+    pm = Foo()
+    pf = Foo()
+    pm.a = np.ones((1, 5))
+    pm.b = np.ones((1, 5))
+    pm.w = np.ones((1, 5))
+    pf.x = np.ones((5,))
+    pf.y = np.ones((5,))
+    pf.z = np.ones((5,))
+    ans = Magic_calc6_(pm, pf)
+    exp = DataFrame(data=[[2.0, 4.0]] * 5,
+                    columns=["a", "b"])
+    assert_frame_equal(ans, exp)
+    # restore normal JIT operation of decorators module
+    del os.environ['NOTAXCALCJIT']
+    importlib.reload(taxcalc.decorators)

taxcalc/tests/test_growdiff.py

@@ -0,0 +1,102 @@
+# CODING-STYLE CHECKS:
+# pycodestyle test_growdiff.py
+
+import os
+import json
+import numpy as np
+import pytest
+from taxcalc import GrowDiff, GrowFactors, Policy
+
+
+def test_year_consistency():
+    assert GrowDiff.JSON_START_YEAR == Policy.JSON_START_YEAR
+    assert GrowDiff.DEFAULT_NUM_YEARS == Policy.DEFAULT_NUM_YEARS
+
+
+def test_update_and_apply_growdiff():
+    gdiff = GrowDiff()
+    # update GrowDiff instance
+    diffs = {
+        'AWAGE': {2014: 0.01,
+                  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)
+    # apply growdiff to GrowFactors instance
+    gf = GrowFactors()
+    syr = GrowDiff.JSON_START_YEAR
+    nyrs = GrowDiff.DEFAULT_NUM_YEARS
+    lyr = syr + nyrs - 1
+    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)]
+    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():
+    start_year = GrowDiff.JSON_START_YEAR
+    gdiff = GrowDiff()
+    assert gdiff.current_year == start_year
+    assert gdiff.has_any_response() is False
+    gdiff.update_growdiff({'AWAGE': {2020: 0.01}})
+    assert gdiff.current_year == start_year
+    assert gdiff.has_any_response() is True
+
+
+def test_description_punctuation(tests_path):
+    """
+    Check that each description ends in a period.
+    """
+    # read JSON file into a dictionary
+    path = os.path.join(tests_path, '..', 'growdiff.json')
+    with open(path, 'r') as jsonfile:
+        dct = json.load(jsonfile)
+    all_desc_ok = True
+    for param in dct.keys():
+        if param == "schema":
+            continue
+        if not dct[param]['description'].endswith('.'):
+            all_desc_ok = False
+            print('param,description=',
+                  str(param),
+                  dct[param]['description'])
+    assert all_desc_ok
+
+
+def test_boolean_value_infomation(tests_path):
+    """
+    Check consistency of boolean_value in growdiff.json file.
+    """
+    # read growdiff.json file into a dictionary
+    path = os.path.join(tests_path, '..', 'growdiff.json')
+    with open(path, 'r') as gddfile:
+        gdd = json.load(gddfile)
+    for param in gdd.keys():
+        if param == "schema":
+            continue
+        val = gdd[param]['value']
+        if isinstance(val, list):
+            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
+        type_is_boolean = gdd[param]['type'] == 'bool'
+        if val_is_boolean and not type_is_boolean:
+            print('param,value_type,val,val_is_boolean=',
+                  str(param),
+                  gdd[param]['value_type'],
+                  val,
+                  val_is_boolean)

taxcalc/tests/test_growfactors.py

@@ -0,0 +1,94 @@
+"""
+Tests of Tax-Calculator GrowFactors class.
+"""
+# CODING-STYLE CHECKS:
+# pycodestyle test_growfactors.py
+# pylint --disable=locally-disabled test_growfactors.py
+
+import os
+import tempfile
+import pytest
+# pylint: disable=import-error
+from taxcalc import GrowFactors, Records, Policy
+
+
+@pytest.fixture(scope='module', name='bad_gf_file')
+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()
+    yield tfile
+    os.remove(tfile.name)
+
+
+def test_improper_usage(bad_gf_file):
+    """
+    Tests of improper usage of GrowFactors object.
+    """
+    with pytest.raises(ValueError):
+        gfo = GrowFactors(dict())
+    with pytest.raises(ValueError):
+        gfo = GrowFactors('non_existent_file.csv')
+    with pytest.raises(ValueError):
+        gfo = GrowFactors(bad_gf_file.name)
+    gfo = GrowFactors()
+    fyr = gfo.first_year
+    lyr = gfo.last_year
+    with pytest.raises(ValueError):
+        gfo.price_inflation_rates(fyr - 1, lyr)
+    with pytest.raises(ValueError):
+        gfo.price_inflation_rates(fyr, lyr + 1)
+    with pytest.raises(ValueError):
+        gfo.price_inflation_rates(lyr, fyr)
+    with pytest.raises(ValueError):
+        gfo.wage_growth_rates(fyr - 1, lyr)
+    with pytest.raises(ValueError):
+        gfo.wage_growth_rates(fyr, lyr + 1)
+    with pytest.raises(ValueError):
+        gfo.wage_growth_rates(lyr, fyr)
+    with pytest.raises(ValueError):
+        gfo.factor_value('BADNAME', fyr)
+    with pytest.raises(ValueError):
+        gfo.factor_value('AWAGE', fyr - 1)
+    with pytest.raises(ValueError):
+        gfo.factor_value('AWAGE', lyr + 1)
+
+
+def test_update_after_use():
+    """
+    Test of improper update after GrowFactors object has been used.
+    """
+    gfo = GrowFactors()
+    gfo.price_inflation_rates(gfo.first_year, gfo.last_year)
+    with pytest.raises(ValueError):
+        gfo.update('AWAGE', 2013, 0.01)
+
+
+def test_proper_usage():
+    """
+    Test proper usage of GrowFactors object.
+    """
+    gfo = GrowFactors()
+    pir = gfo.price_inflation_rates(2013, 2020)
+    assert len(pir) == 8
+    wgr = gfo.wage_growth_rates(2013, 2021)
+    assert len(wgr) == 9
+    val = gfo.factor_value('AWAGE', 2013)
+    assert val > 1.0
+
+
+def test_growfactors_csv_values():
+    """
+    Test numerical contents of growfactors.csv file.
+    """
+    gfo = GrowFactors()
+    min_data_year = min(Records.PUFCSV_YEAR, Records.CPSCSV_YEAR)
+    if min_data_year < Policy.JSON_START_YEAR:
+        for gfname in GrowFactors.VALID_NAMES:
+            val = gfo.factor_value(gfname, min_data_year)
+            assert val == 1