taxcalc 5.1.0__py3-none-any.whl → 5.3.0__py3-none-any.whl

taxcalc/tests/test_compare.py

@@ -204,9 +204,9 @@ def comparison(cname, calc, cmpdata, ofile):
     vardf = add_income_table_row_variable(vardf, 'c00100', SOI_AGI_BINS)
     gbydf = vardf.groupby('table_row', as_index=False, observed=True)
     # write AGI table with ALL row at bottom of ofile
-    ofile.write(f'TABLE for {cname.split(":")[1]}\n')
+    ofile.write(f"TABLE for {cname.split(':')[1]}\n")
     results = '{:23s}\t{:8.3f}\t{:8.3f}\t{:+6.1f}\n'
-    colhead = f'{"AGIcategory":23s}\t{"T-C":>8s}\t{"SOI":>8s}\t{"%diff":>6s}\n'
+    colhead = f"{'AGIcategory':23s}\t{'T-C':>8s}\t{'SOI':>8s}\t{'%diff':>6s}\n"
     ofile.write(colhead)
     # pylint: disable=consider-using-f-string
     txc_tot = 0.

taxcalc/tests/test_consumption.py

@@ -119,9 +119,9 @@ def test_consumption_default_data():
     pdata = consump.specification(meta_data=True, ignore_state=True)
     for pname in pdata.keys():
         if pname.startswith('MPC'):
-            assert pdata[pname]['value'] == [{"value": 0.0, "year": 2013}]
+            assert pdata[pname]['value'] == [{'value': 0.0, 'year': 2013}]
         elif pname.startswith('BEN'):
-            assert pdata[pname]['value'] == [{"value": 1.0, "year": 2013}]
+            assert pdata[pname]['value'] == [{'value': 1.0, 'year': 2013}]
 
 
 def test_consumption_response(cps_subsample):

taxcalc/tests/test_cpscsv.py

@@ -25,6 +25,7 @@ from taxcalc.calculator import Calculator
 
 
 START_YEAR = 2017
+NUM_YEARS = 19
 
 
 @pytest.mark.cpscsv_agg
@@ -33,7 +34,7 @@ def test_agg(tests_path, cps_fullsample):
     Test current-law aggregate taxes using cps.csv file.
     """
     # pylint: disable=too-many-statements,too-many-locals
-    nyrs = 10
+    nyrs = NUM_YEARS
     # create a baseline Policy object with current-law policy parameters
     baseline_policy = Policy()
     # create a Records object (rec) containing all cps.csv input records
@@ -44,7 +45,7 @@ def test_agg(tests_path, cps_fullsample):
     calc_start_year = calc.current_year
     # create aggregate diagnostic table (adt) as a Pandas DataFrame object
     adt = calc.diagnostic_table(nyrs).round(1)  # column labels are int
-    taxes_fullsample = adt.loc["Combined Liability ($b)"]
+    taxes_fullsample = adt.loc['Combined Liability ($b)']
     # compare actual DataFrame, adt, with the expected DataFrame, edt
     aggres_path = os.path.join(tests_path, 'cpscsv_agg_expect.csv')
     edt = pd.read_csv(aggres_path, index_col=False)  # column labels are str
@@ -75,7 +76,7 @@ def test_agg(tests_path, cps_fullsample):
     calc_subsample.advance_to_year(START_YEAR)
     adt_subsample = calc_subsample.diagnostic_table(nyrs)
     # compare combined tax liability from full and sub samples for each year
-    taxes_subsample = adt_subsample.loc["Combined Liability ($b)"]
+    taxes_subsample = adt_subsample.loc['Combined Liability ($b)']
     print('taxes_submsampe = ', taxes_subsample)
     print('TAXES full sample = ', taxes_fullsample)
     msg = ''

taxcalc/tests/test_decorators.py

@@ -24,20 +24,20 @@ from taxcalc.decorators import (
 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"
-           "    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")
+    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():
     """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"
-           "    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")
+    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
 
 
@@ -45,24 +45,26 @@ def test_create_toplevel_function_string_mult_outputs():
     """Test docstring"""
     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)")
-
+    # pylint: disable=inconsistent-quotes
+    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)"
+    )
+    # pylint: enable=inconsistent-quotes
     assert ans == exp
 
 
@@ -70,23 +72,26 @@ def test_create_toplevel_function_string():
     """Test docstring"""
     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)")
+    # pylint: disable=inconsistent-quotes
+    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)"
+    )
+    # pylint: enable=inconsistent-quotes
     assert ans == exp
 
 
@@ -107,7 +112,7 @@ def test_make_apply_function():
     assert ans_no_jit
 
 
-@apply_jit(["a", "b"], ["x", "y", "z"], nopython=True)
+@apply_jit(['a', 'b'], ['x', 'y', 'z'], nopython=True)
 def magic_calc(x, y, z):
     """Function docstring"""
     a = x + y
@@ -178,7 +183,7 @@ def test_magic_apply_jit():
     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"])
+    exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=['a', 'b'])
     assert_frame_equal(xx, exp)
 
 
@@ -192,7 +197,7 @@ def test_magic_apply_jit_swap():
     pf.y = np.ones((5,))
     pf.z = np.ones((5,))
     xx = magic(pf, pm)  # pylint: disable=arguments-out-of-order
-    exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=["a", "b"])
+    exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=['a', 'b'])
     assert_frame_equal(xx, exp)
 
 
@@ -209,7 +214,7 @@ def test_magic_iterate_jit():
     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"])
+    exp = DataFrame(data=[[2.0, 3.0]] * 5, columns=['a', 'b'])
     assert_frame_equal(xx, exp)
 
 
@@ -236,7 +241,7 @@ def test_ret_everything_iterate_jit():
     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"])
+                    columns=['c', 'd', 'e', 'f'])
     assert_frame_equal(ans, exp)
 
 
@@ -259,7 +264,7 @@ def test_function_takes_kwarg():
     pf.z = np.ones((5,))
     ans = magic_calc3(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5,
-                    columns=["a", "b"])
+                    columns=['a', 'b'])
     assert_frame_equal(ans, exp)
 
 
@@ -282,7 +287,7 @@ def test_function_no_parameters_listed():
     pf.z = np.ones((5,))
     ans = magic_calc4(pm, pf)
     exp = DataFrame(data=[[2.0, 3.0]] * 5,
-                    columns=["a", "b"])
+                    columns=['a', 'b'])
     assert_frame_equal(ans, exp)
 
 
@@ -306,7 +311,7 @@ def test_function_parameters_optional():
     pf.z = np.ones((5,))
     ans = magic_calc5(pm, pf)
     exp = DataFrame(data=[[2.0, 4.0]] * 5,
-                    columns=["a", "b"])
+                    columns=['a', 'b'])
     assert_frame_equal(ans, exp)
 
 
@@ -377,7 +382,7 @@ def test_force_no_jit():
     pf.z = np.ones((5,))
     ans = magic_calc6_(pm, pf)
     exp = DataFrame(data=[[2.0, 4.0]] * 5,
-                    columns=["a", "b"])
+                    columns=['a', 'b'])
     assert_frame_equal(ans, exp)
     # restore normal JIT operation of decorators module
     del os.environ['NOTAXCALCJIT']

taxcalc/tests/test_growdiff.py

@@ -67,7 +67,7 @@ def test_description_punctuation(tests_path):
         dct = json.load(jsonfile)
     all_desc_ok = True
     for param in dct.keys():
-        if param == "schema":
+        if param == 'schema':
             continue
         if not dct[param]['description'].endswith('.'):
             all_desc_ok = False
@@ -86,7 +86,7 @@ def test_boolean_value_infomation(tests_path):
     with open(path, 'r', encoding='utf-8') as gddfile:
         gdd = json.load(gddfile)
     for param in gdd.keys():
-        if param == "schema":
+        if param == 'schema':
             continue
         val = gdd[param]['value']
         if isinstance(val, list):

taxcalc/tests/test_parameters.py

@@ -86,13 +86,13 @@ PARAMS_JSON = json.dumps({
 })
 
 
-@pytest.fixture(scope='module', name='params_json_file')
+@pytest.fixture(scope="module", name="params_json_file")
 def fixture_params_json_file():
     """
     Define JSON DEFAULTS file for Parameters-derived Params class.
     """
-    with tempfile.NamedTemporaryFile(mode='a', delete=False) as pfile:
-        pfile.write(PARAMS_JSON + '\n')
+    with tempfile.NamedTemporaryFile(mode="a", delete=False) as pfile:
+        pfile.write(PARAMS_JSON + "\n")
     pfile.close()
     yield pfile
     os.remove(pfile.name)
@@ -100,22 +100,22 @@ def fixture_params_json_file():
 
 @pytest.mark.parametrize("revision, expect", [
     ({}, ""),
-    ({'real_param': {2004: 1.9}}, "error"),
-    ({'int_param': {2004: [3.6]}}, "raise"),
+    ({"real_param": {2004: 1.9}}, "error"),
+    ({"int_param": {2004: [3.6]}}, "raise"),
     ({"int_param": {2004: [3]}}, "raise"),
     ({"label_param": {2004: [1, 2]}}, "noerror"),
     ({"label_param": {2004: [[1, 2]]}}, "raise"),
     ({"label_param": {2004: [1, 2, 3]}}, "raise"),
-    ({'bool_param': {2004: [4.9]}}, "raise"),
-    ({'str_param': {2004: [9]}}, "raise"),
-    ({'str_param': {2004: 'nonlinear'}}, "noerror"),
-    ({'str_param': {2004: 'unknownvalue'}}, "error"),
-    ({'str_param': {2004: ['nonlinear']}}, "raise"),
-    ({'real_param': {2004: 'linear'}}, "raise"),
-    ({'real_param': {2004: [0.2, 0.3]}}, "raise"),
-    ({'removed_param': {2004: 0.1}}, "raise"),
-    ({'real_param-indexed': {2004: True}}, "raise"),
-    ({'unknown_param-indexed': {2004: False}}, "raise")
+    ({"bool_param": {2004: [4.9]}}, "raise"),
+    ({"str_param": {2004: [9]}}, "raise"),
+    ({"str_param": {2004: "nonlinear"}}, "noerror"),
+    ({"str_param": {2004: "unknownvalue"}}, "error"),
+    ({"str_param": {2004: ["nonlinear"]}}, "raise"),
+    ({"real_param": {2004: "linear"}}, "raise"),
+    ({"real_param": {2004: [0.2, 0.3]}}, "raise"),
+    ({"removed_param": {2004: 0.1}}, "raise"),
+    ({"real_param-indexed": {2004: True}}, "raise"),
+    ({"unknown_param-indexed": {2004: False}}, "raise")
 ])
 def test_params_class(revision, expect, params_json_file):
     """
@@ -129,12 +129,12 @@ def test_params_class(revision, expect, params_json_file):
         # pylint: disable=abstract-method
 
         DEFAULTS_FILE_NAME = params_json_file.name
-        DEFAULTS_FILE_PATH = ''
+        DEFAULTS_FILE_PATH = ""
         START_YEAR = 2001
         LAST_YEAR = 2010
         NUM_YEARS = LAST_YEAR - START_YEAR + 1
         REMOVED_PARAMS = {
-            'removed_param': 'has been removed'
+            "removed_param": "has been removed"
         }
 
         def __init__(self):
@@ -169,17 +169,17 @@ def test_params_class(revision, expect, params_json_file):
             prms.set_year(2011)
         return
 
-    if expect == 'raise':
+    if expect == "raise":
         with pytest.raises(paramtools.ValidationError):
             prms.update_params(revision)
-    elif expect == 'noerror':
+    elif expect == "noerror":
         prms.update_params(revision)
         assert not prms.errors
-    elif expect == 'error':
+    elif expect == "error":
         with pytest.raises(paramtools.ValidationError):
             prms.update_params(revision)
         assert prms.errors
-    elif expect == 'warn':
+    elif expect == "warn":
         with pytest.raises(paramtools.ValidationError):
             prms.update_params(revision)
         assert prms.warnings
@@ -198,9 +198,9 @@ def test_json_file_contents(tests_path, fname):
     last_known_year = Policy.LAST_KNOWN_YEAR  # for indexed parameter values
     known_years = set(range(first_year, last_known_year + 1))
     # check elements in each parameter sub-dictionary
-    failures = ''
+    failures = ""
     path = os.path.join(tests_path, "..", fname)
-    with open(path, 'r', encoding='utf-8') as f:
+    with open(path, "r", encoding="utf-8") as f:
         allparams = json.loads(f.read())
     for pname in allparams:
         if pname == "schema":
@@ -208,31 +208,37 @@ def test_json_file_contents(tests_path, fname):
         # check that param contains required keys
         param = allparams[pname]
         # check that indexable and indexed are False in many files
-        if fname != 'policy_current_law.json':
-            assert param.get('indexable', False) is False
-            assert param.get('indexed', False) is False
+        if fname != "policy_current_law.json":
+            assert param.get("indexable", False) is False
+            assert param.get("indexed", False) is False
         # check that indexable is True when indexed is True
-        if param.get('indexed', False) and not param.get('indexable', False):
+        if param.get("indexed", False) and not param.get("indexable", False):
+            pindexed = param.get("indexed", False)
+            pindexable = param.get("indexable", False)
             msg = (
-                f'param:<{pname}>; '
-                f'indexed={param.get("indexed", False)}; '
-                f'indexable={param.get("indexable", False)}\n'
+                f"param:<{pname}>; "
+                f"indexed={pindexed}; "
+                f"indexable={pindexable}\n"
             )
             failures += msg
         # check that indexable param has value_type float
-        if param.get('indexable', False) and param['type'] != 'float':
+        if param.get("indexable", False) and param["type"] != "float":
+            ptype = param["type"]
+            pindexable = param.get("indexable", False)
             msg = (
-                f'param:<{pname}>; '
-                f'type={param["type"]}; '
-                f'indexable={param.get("indexable", False)}\n'
+                f"param:<{pname}>; "
+                f"type={ptype}; "
+                f"indexable={pindexable}\n"
             )
             failures += msg
         # ensure that indexable is False when value_type is not real
-        if param.get('indexable', False) and param['type'] != 'float':
+        if param.get("indexable", False) and param["type"] != "float":
+            pindexable = param.get("indexable", False)
+            ptype = param["value_type"]
             msg = (
-                f'param:<{pname}>; '
-                f'indexable={param.get("indexable", False)}; '
-                f'type={param["value_type"]}\n'
+                f"param:<{pname}>; "
+                f"indexable={pindexable}; "
+                f"type={ptype}\n"
             )
             failures += msg
     o = None
@@ -250,7 +256,7 @@ def test_json_file_contents(tests_path, fname):
         for y in known_years:
             o.set_year(y)
             if np.isnan(getattr(o, param)).any():
-                msg = f'param:<{param}>; not found in year={y}\n'
+                msg = f"param:<{param}>; not found in year={y}\n"
                 failures += msg
     if failures:
         raise ValueError(failures)
@@ -265,28 +271,28 @@ def test_parameters_mentioned(tests_path, jfname, pfname):
     Make sure each JSON parameter is mentioned in PYTHON code file.
     """
     # read JSON parameter file into a dictionary
-    path = os.path.join(tests_path, '..', jfname)
-    with open(path, 'r', encoding='utf-8') as pfile:
+    path = os.path.join(tests_path, "..", jfname)
+    with open(path, "r", encoding="utf-8") as pfile:
         allparams = json.load(pfile)
     assert isinstance(allparams, dict)
     # read PYTHON code file text
     # pylint: disable=consider-using-join
-    if pfname == 'consumption.py':
+    if pfname == "consumption.py":
         # consumption.py does not explicitly name the parameters
-        code_text = ''
+        code_text = ""
         for var in Consumption.RESPONSE_VARS:
-            code_text += f'MPC_{var}\n'
+            code_text += f"MPC_{var}\n"
         for var in Consumption.BENEFIT_VARS:
-            code_text += f'BEN_{var}_value\n'
-    elif pfname == 'growdiff.py':
+            code_text += f"BEN_{var}_value\n"
+    elif pfname == "growdiff.py":
         # growdiff.py does not explicitly name the parameters
-        code_text = ''
+        code_text = ""
         for var in GrowFactors.VALID_NAMES:
-            code_text += f'{var}\n'
+            code_text += f"{var}\n"
     else:
         # parameters are explicitly named in PYTHON file
-        path = os.path.join(tests_path, '..', pfname)
-        with open(path, 'r', encoding='utf-8') as pfile:
+        path = os.path.join(tests_path, "..", pfname)
+        with open(path, "r", encoding="utf-8") as pfile:
             code_text = pfile.read()
     # check that each param (without leading _) is mentioned in code text
     for pname in allparams:
@@ -491,7 +497,7 @@ def test_expand_2d_variable_rates():
     for i in range(0, 4):
         idx = i + len(ary) - 1
         cur = np.array(cur * (1.0 + irates[idx]))
-        print('cur is ', cur)
+        print("cur is ", cur)
         exp2.append(cur)
     exp1 = np.array([1., 2., 3., 4.])
     exp = np.zeros((5, 4))
@@ -597,13 +603,13 @@ def test_read_json_revision(good_revision):
     # pllint: disable=private-method
     with pytest.raises(TypeError):
         # error because first obj argument is neither None nor a string
-        Parameters._read_json_revision([], '')
+        Parameters._read_json_revision([], "")
     with pytest.raises(ValueError):
         # error because second topkey argument must be a string
         Parameters._read_json_revision(good_revision, 999)
     with pytest.raises(ValueError):
         # error because second topkey argument is not in good_revision
-        Parameters._read_json_revision(good_revision, 'unknown_topkey')
+        Parameters._read_json_revision(good_revision, "unknown_topkey")
 
 
 @pytest.mark.parametrize("params,is_paramtools", [