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

taxcalc/tests/test_records.py

@@ -1,39 +1,49 @@
+"""
+Test Records class and its methods.
+"""
 # CODING-STYLE CHECKS:
 # pycodestyle test_records.py
+# pylint --disable=locally-disabled test_records.py
 
 import os
 import json
+from io import StringIO
 import numpy as np
-from numpy.testing import assert_array_equal
 import pandas as pd
 import pytest
-from io import StringIO
-from taxcalc import GrowFactors, Policy, Records, Calculator
+from taxcalc import GrowFactors, Policy, Records
 
 
-def test_incorrect_Records_instantiation(cps_subsample):
+def test_incorrect_records_instantiation(cps_subsample, cps_fullsample):
+    """Test docstring"""
     with pytest.raises(ValueError):
-        recs = Records(data=list())
+        _ = Records(data=[])
     with pytest.raises(ValueError):
-        recs = Records(data=cps_subsample, gfactors=list())
+        _ = Records(data=cps_subsample, gfactors=[])
     with pytest.raises(ValueError):
-        recs = Records(data=cps_subsample, gfactors=None, weights=list())
+        _ = Records(data=cps_subsample, gfactors=None, weights=[])
     with pytest.raises(ValueError):
-        recs = Records(data=cps_subsample, gfactors=None, weights=None,
-                       start_year=list())
+        _ = Records(data=cps_subsample, gfactors=None, weights=None,
+                    start_year=[])
     with pytest.raises(ValueError):
-        recs = Records(data=cps_subsample, gfactors=None, weights=None,
-                       adjust_ratios=list())
+        _ = Records(data=cps_subsample, gfactors=None, weights=None,
+                    adjust_ratios=[])
+    # test error raise when num of records is greater than num of weights
+    wghts_path = os.path.join(Records.CODE_PATH, Records.PUF_WEIGHTS_FILENAME)
+    puf_wghts = pd.read_csv(wghts_path)
+    with pytest.raises(ValueError):
+        _ = Records(data=cps_fullsample, weights=puf_wghts, start_year=2020)
 
 
-def test_correct_Records_instantiation(cps_subsample):
+def test_correct_records_instantiation(cps_subsample):
+    """Test docstring"""
     rec1 = Records.cps_constructor(data=cps_subsample, gfactors=None)
     assert rec1
-    assert np.all(rec1.MARS != 0)
-    assert rec1.current_year == rec1.data_year
-    sum_e00200_in_cps_year = rec1.e00200.sum()
+    assert np.all(getattr(rec1, 'MARS') != 0)
+    assert getattr(rec1, 'current_year') == getattr(rec1, 'data_year')
+    sum_e00200_in_cps_year = getattr(rec1, 'e00200').sum()
     rec1.increment_year()
-    sum_e00200_in_cps_year_plus_one = rec1.e00200.sum()
+    sum_e00200_in_cps_year_plus_one = getattr(rec1, 'e00200').sum()
     assert sum_e00200_in_cps_year_plus_one == sum_e00200_in_cps_year
     wghts_path = os.path.join(Records.CODE_PATH, Records.CPS_WEIGHTS_FILENAME)
     wghts_df = pd.read_csv(wghts_path)
@@ -46,80 +56,83 @@ def test_correct_Records_instantiation(cps_subsample):
                    adjust_ratios=ratios_df,
                    exact_calculations=False)
     assert rec2
-    assert np.all(rec2.MARS != 0)
-    assert rec2.current_year == rec2.data_year
+    assert np.all(getattr(rec2, 'MARS') != 0)
+    assert getattr(rec2, 'current_year') == getattr(rec2, 'data_year')
 
 
 def test_read_cps_data(cps_fullsample):
+    """Test docstring"""
     data = Records.read_cps_data()
     assert data.equals(cps_fullsample)
 
 
 @pytest.mark.parametrize("csv", [
     (
-        u'RECID,MARS,e00200,e00200p,e00200s\n'
-        u'1,    2,   200000, 200000,   0.03\n'
+        'RECID,MARS,e00200,e00200p,e00200s\n'
+        '1,    2,   200000, 200000,   0.03\n'
     ),
     (
-        u'RECID,MARS,e00900,e00900p,e00900s\n'
-        u'1,    2,   200000, 200000,   0.03\n'
+        'RECID,MARS,e00900,e00900p,e00900s\n'
+        '1,    2,   200000, 200000,   0.03\n'
     ),
     (
-        u'RECID,MARS,e02100,e02100p,e02100s\n'
-        u'1,    2,   200000, 200000,   0.03\n'
+        'RECID,MARS,e02100,e02100p,e02100s\n'
+        '1,    2,   200000, 200000,   0.03\n'
     ),
     (
-        u'RECID,MARS,e00200,e00200p,e00200s\n'
-        u'1,    4,   200000, 100000, 100000\n'
+        'RECID,MARS,e00200,e00200p,e00200s\n'
+        '1,    4,   200000, 100000, 100000\n'
     ),
     (
-        u'RECID,MARS,e00900,e00900p,e00900s\n'
-        u'1,    4,   200000, 100000, 100000\n'
+        'RECID,MARS,e00900,e00900p,e00900s\n'
+        '1,    4,   200000, 100000, 100000\n'
     ),
     (
-        u'RECID,MARS,e02100,e02100p,e02100s\n'
-        u'1,    4,   200000, 100000, 100000\n'
+        'RECID,MARS,e02100,e02100p,e02100s\n'
+        '1,    4,   200000, 100000, 100000\n'
     ),
     (
-        u'RECID,MARS,k1bx14s\n'
-        u'1,    4,   0.03\n'
+        'RECID,MARS,k1bx14s\n'
+        '1,    4,   0.03\n'
     ),
     (
-        u'RxCID,MARS\n'
-        u'1,    2\n'
+        'RxCID,MARS\n'
+        '1,    2\n'
     ),
     (
-        u'RECID,e00300\n'
-        u'1,    456789\n'
+        'RECID,e00300\n'
+        '1,    456789\n'
     ),
     (
-        u'RECID,MARS\n'
-        u'1,    6\n'
+        'RECID,MARS\n'
+        '1,    6\n'
     ),
     (
-        u'RECID,MARS,EIC\n'
-        u'1,    5,   4\n'
+        'RECID,MARS,EIC\n'
+        '1,    5,   4\n'
     ),
     (
-        u'RECID,MARS,e00600,e00650\n'
-        u'1,    1,        8,     9\n'
+        'RECID,MARS,e00600,e00650\n'
+        '1,    1,        8,     9\n'
     ),
     (
-        u'RECID,MARS,e01500,e01700\n'
-        u'1,    1,        6,     7\n'
+        'RECID,MARS,e01500,e01700\n'
+        '1,    1,        6,     7\n'
     ),
     (
-        u'RECID,MARS,PT_SSTB_income\n'
-        u'1,    1,   2\n'
+        'RECID,MARS,PT_SSTB_income\n'
+        '1,    1,   2\n'
     )
 ])
 def test_read_data(csv):
+    """Test docstring"""
     df = pd.read_csv(StringIO(csv))
     with pytest.raises(ValueError):
         Records(data=df)
 
 
 def test_for_duplicate_names():
+    """Test docstring"""
     records_varinfo = Records(data=None)
     varnames = set()
     for varname in records_varinfo.USABLE_READ_VARS:
@@ -142,15 +155,16 @@ def test_records_variables_content(tests_path):
     """
     Check completeness and consistency of records_variables.json content.
     """
+    # pylint: disable=too-many-locals
+
     # specify test information
     reqkeys = ['type', 'desc', 'form']
     first_year = Policy.JSON_START_YEAR
     last_form_year = 2017
     # read JSON variable file into a dictionary
     path = os.path.join(tests_path, '..', 'records_variables.json')
-    vfile = open(path, 'r')
-    allvars = json.load(vfile)
-    vfile.close()
+    with open(path, 'r', encoding='utf-8') as vfile:
+        allvars = json.load(vfile)
     assert isinstance(allvars, dict)
     # check elements in each variable dictionary
     for iotype in ['read', 'calc']:
@@ -181,20 +195,19 @@ def test_records_variables_content(tests_path):
                     indefinite_yrange = False
                     eyr = int(yrlist[1])
                     if fyr != (prior_eyr + 1):
-                        msg1 = '{} fyr {}'.format(vname, fyr)
-                        msg2 = '!= prior_eyr_1 {}'.format(prior_eyr + 1)
+                        msg1 = f'{vname} fyr {fyr}'
+                        msg2 = f'!= prior_eyr_1 {prior_eyr + 1}'
                         assert msg1 == msg2
                     if eyr > last_form_year:
-                        msg1 = '{} eyr {}'.format(vname, eyr)
-                        msg2 = '> last_form_year {}'.format(last_form_year)
+                        msg1 = f'{vname} eyr {eyr}'
+                        msg2 = f'> last_form_year {last_form_year}'
                         assert msg1 == msg2
                     prior_eyr = eyr
             if not indefinite_yrange and len(yranges) > 0:
-                prior_ey_ok = (prior_eyr == last_form_year or
-                               prior_eyr == last_form_year - 1)
+                prior_ey_ok = prior_eyr in (last_form_year, last_form_year - 1)
                 if not prior_ey_ok:
-                    msg1 = '{} prior_eyr {}'.format(vname, prior_eyr)
-                    msg2 = '!= last_form_year {}'.format(last_form_year)
+                    msg1 = f'{vname} prior_eyr {prior_eyr}'
+                    msg2 = f'!= last_form_year {last_form_year}'
                     assert msg1 == msg2
 
 
@@ -206,7 +219,7 @@ def test_csv_input_vars_md_contents(tests_path):
     civ_path = os.path.join(tests_path, '..', 'validation',
                             'CSV_INPUT_VARS.md')
     civ_set = set()
-    with open(civ_path, 'r') as civfile:
+    with open(civ_path, 'r', encoding='utf-8') as civfile:
         msg = 'DUPLICATE VARIABLE(S) IN CSV_INPUT_VARS.MD FILE:\n'
         found_duplicates = False
         for line in civfile:
@@ -219,7 +232,7 @@ def test_csv_input_vars_md_contents(tests_path):
                 continue  # skip two lines that are the table head
             if var in civ_set:
                 found_duplicates = True
-                msg += 'VARIABLE= {}\n'.format(var)
+                msg += f'VARIABLE= {var}\n'
             else:
                 civ_set.add(var)
         if found_duplicates:
@@ -230,5 +243,5 @@ def test_csv_input_vars_md_contents(tests_path):
         valid_less_civ = records_varinfo.USABLE_READ_VARS - civ_set
         msg = 'VARIABLE(S) IN USABLE_READ_VARS BUT NOT CSV_INPUT_VARS.MD:\n'
         for var in valid_less_civ:
-            msg += 'VARIABLE= {}\n'.format(var)
+            msg += f'VARIABLE= {var}\n'  # pylint: disable=consider-using-join
         raise ValueError(msg)

taxcalc/tests/test_reforms.py

@@ -11,8 +11,9 @@ import json
 import pytest
 import numpy as np
 import pandas as pd
-# pylint: disable=import-error
-from taxcalc import Calculator, Policy, Records
+from taxcalc.policy import Policy
+from taxcalc.records import Records
+from taxcalc.calculator import Calculator
 
 
 def test_2017_law_reform(tests_path):
@@ -24,7 +25,7 @@ def test_2017_law_reform(tests_path):
     # create pre metadata dictionary for 2017_law.json reform in fyear
     pol = Policy()
     reform_file = os.path.join(tests_path, '..', 'reforms', '2017_law.json')
-    with open(reform_file, 'r') as rfile:
+    with open(reform_file, 'r', encoding='utf-8') as rfile:
         rtext = rfile.read()
     pol.implement_reform(Policy.read_json_reform(rtext))
     assert not pol.parameter_warnings
@@ -57,7 +58,7 @@ def test_2017_law_reform(tests_path):
     }
     assert isinstance(pre_expect, dict)
     assert set(pre_expect.keys()).issubset(set(pre_mdata.keys()))
-    for name in pre_expect:
+    for name in pre_expect:  # pylint: disable=consider-using-dict-items
         aval = pre_mdata[name]
         if aval.ndim == 2:
             act = aval[0][0]  # comparing only first item in a vector parameter
@@ -65,11 +66,11 @@ def test_2017_law_reform(tests_path):
             act = aval[0]
         exp = pre_expect[name]['value']
         if pre_expect[name]['relation'] == '<':
-            assert act < exp, '{} a={} !< e={}'.format(name, act, exp)
+            assert act < exp, f'{name} a={act} !< e={exp}'
         elif pre_expect[name]['relation'] == '>':
-            assert act > exp, '{} a={} !> e={}'.format(name, act, exp)
+            assert act > exp, f'{name} a={act} !> e={exp}'
         elif pre_expect[name]['relation'] == '=':
-            assert act == exp, '{} a={} != e={}'.format(name, act, exp)
+            assert act == exp, f'{name} a={act} != e={exp}'
 
 
 @pytest.mark.rtr
@@ -88,7 +89,8 @@ def test_round_trip_reforms(fyear, tests_path):
     and subsequent reform files that represent recent legislation are
     specified in a consistent manner.
     """
-    # pylint: disable=too-many-locals
+    # pylint: disable=too-many-locals,too-many-statements
+
     # create clp metadata dictionary for current-law policy in fyear
     clp_pol = Policy()
     clp_pol.set_year(fyear)
@@ -143,21 +145,23 @@ def test_round_trip_reforms(fyear, tests_path):
     assert clp_mdata.keys() == rtr_mdata.keys()
     fail_dump = False
     if fail_dump:
-        rtr_fails = open('fails_rtr', 'w', encoding='utf-8')
-        clp_fails = open('fails_clp', 'w', encoding='utf-8')
+        rtr_fails = open(  # pylint: disable=consider-using-with
+            'fails_rtr', 'w', encoding='utf-8'
+        )
+        clp_fails = open(  # pylint: disable=consider-using-with
+            'fails_clp', 'w', encoding='utf-8'
+        )
     fail_params = []
     msg = '\nRound-trip-reform and current-law-policy param values differ for:'
-    for pname in clp_mdata.keys():
+    for pname in clp_mdata.keys():  # pylint: disable=consider-using-dict-items
         rtr_val = rtr_mdata[pname]
         clp_val = clp_mdata[pname]
         if not np.allclose(rtr_val, clp_val):
             fail_params.append(pname)
-            msg += '\n  {} in {} : rtr={} clp={}'.format(
-                pname, fyear, rtr_val, clp_val
-            )
+            msg += '\n  {pname} in {fyear} : rtr={rtr_val} clp={clp_val}'
             if fail_dump:
-                rtr_fails.write('{} {} {}\n'.format(pname, fyear, rtr_val))
-                clp_fails.write('{} {} {}\n'.format(pname, fyear, clp_val))
+                rtr_fails.write(f'{pname} {fyear} {rtr_val}\n')
+                clp_fails.write(f'{pname} {fyear} {clp_val}\n')
     if fail_dump:
         rtr_fails.close()
         clp_fails.close()
@@ -188,7 +192,7 @@ def test_reform_json_and_output(tests_path):
         # varnames  AGI    STD         TaxInc    ITAX     PTAX
         stats = calc.dataframe(varlist)
         stats['RECID'] = stats['RECID'].astype(int)
-        with open(resfilename, 'w') as resfile:
+        with open(resfilename, 'w', encoding='utf-8') as resfile:
             stats.to_csv(resfile, index=False, float_format='%.2f')
 
     # embedded function used only in test_reform_json_and_output
@@ -217,7 +221,7 @@ def test_reform_json_and_output(tests_path):
                     weights=None,
                     adjust_ratios=None)
     # specify list of reform failures
-    failures = list()
+    failures = []
     # specify current-law-policy Calculator object
     calc = Calculator(policy=Policy(), records=cases, verbose=False)
     calc.advance_to_year(tax_year)
@@ -239,7 +243,7 @@ def test_reform_json_and_output(tests_path):
         if jrf.endswith('ext.json'):
             continue  # skip ext.json, which is tested below in test_ext_reform
         # determine reform's baseline by reading contents of jrf
-        with open(jrf, 'r') as rfile:
+        with open(jrf, 'r', encoding='utf-8') as rfile:
             jrf_text = rfile.read()
         pre_tcja_baseline = 'Reform_Baseline: 2017_law.json' in jrf_text
         # implement the reform relative to its baseline
@@ -263,7 +267,7 @@ def test_reform_json_and_output(tests_path):
     if failures:
         msg = 'Following reforms have res-vs-out differences:\n'
         for ref in failures:
-            msg += '{}\n'.format(os.path.basename(ref))
+            msg += f'{os.path.basename(ref)}\n'
         raise ValueError(msg)
 
 
@@ -285,7 +289,7 @@ def reform_results(rid, reform_dict, puf_data, reform_2017_law):
     calc1 = Calculator(policy=pol, records=rec, verbose=False)
     # create reform Calculator object, calc2
     start_year = reform_dict['start_year']
-    reform = dict()
+    reform = {}
     for name, value in reform_dict['value'].items():
         reform[name] = {start_year: value}
     pol.implement_reform(reform)
@@ -296,7 +300,7 @@ def reform_results(rid, reform_dict, puf_data, reform_2017_law):
     # calculate baseline and reform output for several years
     output_type = reform_dict['output_type']
     num_years = 4
-    results = list()
+    results = []
     for _ in range(0, num_years):
         calc1.calc_all()
         baseline = calc1.array(output_type)
@@ -308,9 +312,9 @@ def reform_results(rid, reform_dict, puf_data, reform_2017_law):
         calc1.increment_year()
         calc2.increment_year()
     # write actual results to actual_str
-    actual_str = '{}'.format(rid)
+    actual_str = f'{rid}'
     for iyr in range(0, num_years):
-        actual_str += ',{:.1f}'.format(results[iyr])
+        actual_str += f',{results[iyr]:.1f}'
     return actual_str
 
 
@@ -329,7 +333,7 @@ def fixture_reforms_dict(tests_path):
     Read reforms.json and convert to dictionary.
     """
     reforms_path = os.path.join(tests_path, 'reforms.json')
-    with open(reforms_path, 'r') as rfile:
+    with open(reforms_path, 'r', encoding='utf-8') as rfile:
         rjson = rfile.read()
     return json.loads(rjson)
 
@@ -338,21 +342,20 @@ NUM_REFORMS = 64  # when changing this also change num_reforms in conftest.py
 
 
 @pytest.mark.requires_pufcsv
-@pytest.mark.parametrize('rid', [i for i in range(1, NUM_REFORMS + 1)])
+@pytest.mark.parametrize('rid', list(range(1, NUM_REFORMS + 1)))
 def test_reforms(rid, test_reforms_init, tests_path, baseline_2017_law,
                  reforms_dict, puf_subsample):
     """
     Write actual reform results to files.
     """
-    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     assert test_reforms_init == NUM_REFORMS
     actual = reform_results(rid, reforms_dict[str(rid)],
                             puf_subsample, baseline_2017_law)
-    afile_path = os.path.join(tests_path,
-                              'reform_actual_{}.csv'.format(rid))
-    with open(afile_path, 'w') as afile:
+    afile_path = os.path.join(tests_path, f'reform_actual_{rid}.csv')
+    with open(afile_path, 'w', encoding='utf-8') as afile:
         afile.write('rid,res1,res2,res3,res4\n')
-        afile.write('{}\n'.format(actual))
+        afile.write(f'{actual}\n')
 
 
 @pytest.mark.extend_tcja

taxcalc/tests/test_responses.py

@@ -7,8 +7,8 @@ Test example JSON response assumption files in taxcalc/responses directory
 
 import os
 import glob
-# pylint: disable=import-error
-from taxcalc import Consumption, GrowDiff
+from taxcalc.consumption import Consumption
+from taxcalc.growdiff import GrowDiff
 
 
 def test_response_json(tests_path):
@@ -20,8 +20,8 @@ def test_response_json(tests_path):
     responses_path = os.path.join(tests_path, '..', 'responses', '*.json')
     for jpf in glob.glob(responses_path):
         # read contents of jpf (JSON parameter filename)
-        jfile = open(jpf, 'r')
-        jpf_text = jfile.read()
+        with open(jpf, 'r', encoding='utf-8') as jfile:
+            jpf_text = jfile.read()
         # check that jpf_text can be used to construct objects
         response_file = ('"consumption"' in jpf_text and
                          '"growdiff_baseline"' in jpf_text and