taxcalc 5.2.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

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", [
@@ -620,3 +626,45 @@ def test_read_json_revision_foramts(params, is_paramtools):
     assert is_paramtools_format(result) is is_paramtools
     if is_paramtools:
         assert result == json.loads(params)["consumption"]
+
+
+def test_compatible_data_presence():
+    """
+    Test that every parameter in the policy_current_law.json file
+    has a compatible_data field that is a dictionary.
+    """
+    compatible_data_keys_set = set(["puf", "cps"])
+
+    # nested function used only in test_compatible_data_presence test
+    def valid_compatible_data(compatible_data):
+        """
+        Return True if compatible_data is a valid dictionary;
+        otherwise return False
+        """
+        if not isinstance(compatible_data, dict):
+            return False
+        if set(compatible_data.keys()) != compatible_data_keys_set:
+            return False
+        for key in compatible_data:
+            boolean = (compatible_data[key] is True or
+                       compatible_data[key] is False)
+            if not boolean:
+                return False
+        return True
+
+    # main logic of test_compatible_data_presence test
+    clp = Policy()
+    allparams = clp.metadata()
+    problem_pnames = []
+    for pname in allparams:
+        if "compatible_data" in allparams[pname]:
+            compatible_data = allparams[pname]["compatible_data"]
+        else:
+            compatible_data = None
+        if not valid_compatible_data(compatible_data):
+            problem_pnames.append(pname)
+    if problem_pnames:
+        msg = "{} has no or invalid compatible_data field"
+        for pname in problem_pnames:
+            print(msg.format(pname))
+        assert False, "ERROR: list of problem_pnames is above"