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

taxcalc/tests/test_pufcsv.py

@@ -8,8 +8,6 @@ and from the Census CPS file for the corresponding year.  If you have
 acquired from IRS the most recent SOI PUF file and want to execute
 this program, contact the Tax-Calculator development team to discuss
 your options.
-
-Read Tax-Calculator/TESTING.md for details.
 """
 # CODING-STYLE CHECKS:
 # pycodestyle test_pufcsv.py
@@ -20,8 +18,9 @@ import json
 import pytest
 import numpy as np
 import pandas as pd
-# pylint: disable=import-error
-from taxcalc import Policy, Records, Calculator
+from taxcalc.policy import Policy
+from taxcalc.records import Records
+from taxcalc.calculator import Calculator
 
 
 START_YEAR = 2017
@@ -57,7 +56,7 @@ def test_agg(tests_path, puf_fullsample):
         if not np.allclose(adt[icol].values, edt[str(icol)].values):
             diffs = True
     if diffs:
-        new_filename = '{}{}'.format(aggres_path[:-10], 'actual.csv')
+        new_filename = f'{aggres_path[:-10]}actual.csv'
         adt.to_csv(new_filename, float_format='%.1f')
         msg = 'PUFCSV AGG RESULTS DIFFER FOR FULL-SAMPLE\n'
         msg += '-------------------------------------------------\n'
@@ -118,27 +117,32 @@ def mtr_bin_counts(mtr_data, bin_edges, recid):
     res = ''
     (bincount, _) = np.histogram(mtr_data.round(decimals=4), bins=bin_edges)
     sum_bincount = np.sum(bincount)
-    res += '{} :'.format(sum_bincount)
+    res += f'{sum_bincount} :'
     for idx in range(len(bin_edges) - 1):
-        res += ' {:6d}'.format(bincount[idx])
+        res += f' {bincount[idx]:6d}'
     res += '\n'
     if sum_bincount < mtr_data.size:
         res += 'WARNING: sum of bin counts is too low\n'
-        recinfo = '         mtr={:.2f} for recid={}\n'
         mtr_min = mtr_data.min()
         mtr_max = mtr_data.max()
         bin_min = min(bin_edges)
         bin_max = max(bin_edges)
         if mtr_min < bin_min:
-            res += '         min(mtr)={:.2f}\n'.format(mtr_min)
+            res += f'         min(mtr)={mtr_min:.2f}\n'
             for idx in range(mtr_data.size):
                 if mtr_data[idx] < bin_min:
-                    res += recinfo.format(mtr_data[idx], recid[idx])
+                    res += (
+                        f'         mtr={mtr_data[idx]:.2f} '
+                        f'for recid={recid[idx]}\n'
+                    )
         if mtr_max > bin_max:
-            res += '         max(mtr)={:.2f}\n'.format(mtr_max)
+            res += f'         max(mtr)={mtr_max:.2f}\n'
             for idx in range(mtr_data.size):
                 if mtr_data[idx] > bin_max:
-                    res += recinfo.format(mtr_data[idx], recid[idx])
+                    res += (
+                        f'         mtr={mtr_data[idx]:.2f} '
+                        f'for recid={recid[idx]}\n'
+                    )
     return res
 
 
@@ -169,24 +173,20 @@ def nonsmall_diffs(linelist1, linelist2, small=0.0):
     for line1, line2 in zip(linelist1, linelist2):
         if line1 == line2:
             continue
-        else:
-            tokens1 = line1.replace(',', '').split()
-            tokens2 = line2.replace(',', '').split()
-            for tok1, tok2 in zip(tokens1, tokens2):
-                tok1_isfloat = isfloat(tok1)
-                tok2_isfloat = isfloat(tok2)
-                if tok1_isfloat and tok2_isfloat:
-                    if abs(float(tok1) - float(tok2)) <= smallamt:
-                        continue
-                    else:
-                        return True
-                elif not tok1_isfloat and not tok2_isfloat:
-                    if tok1 == tok2:
-                        continue
-                    else:
-                        return True
-                else:
-                    return True
+        tokens1 = line1.replace(',', '').split()
+        tokens2 = line2.replace(',', '').split()
+        for tok1, tok2 in zip(tokens1, tokens2):
+            tok1_isfloat = isfloat(tok1)
+            tok2_isfloat = isfloat(tok2)
+            if tok1_isfloat and tok2_isfloat:
+                if abs(float(tok1) - float(tok2)) <= smallamt:
+                    continue
+                return True
+            if not tok1_isfloat and not tok2_isfloat:
+                if tok1 == tok2:
+                    continue
+                return True
+            return True
         return False
 
 
@@ -207,7 +207,7 @@ def test_mtr(tests_path, puf_path):
         res += 'MTR computed using NEGATIVE finite_diff '
     else:
         res += 'MTR computed using POSITIVE finite_diff '
-    res += 'for tax year {}\n'.format(MTR_TAX_YEAR)
+    res += f'for tax year {MTR_TAX_YEAR}\n'
     # create a Policy object (clp) containing current-law policy parameters
     clp = Policy()
     clp.set_year(MTR_TAX_YEAR)
@@ -216,15 +216,15 @@ def test_mtr(tests_path, puf_path):
     recid = puf.RECID  # pylint: disable=no-member
     # create a Calculator object using clp policy and puf records
     calc = Calculator(policy=clp, records=puf)
-    res += '{} = {}\n'.format('Total number of data records', puf.array_length)
+    res += f'Total number of data records = {puf.array_length}\n'
     res += 'PTAX mtr histogram bin edges:\n'
-    res += '     {}\n'.format(PTAX_MTR_BIN_EDGES)
+    res += f'     {PTAX_MTR_BIN_EDGES}\n'
     res += 'ITAX mtr histogram bin edges:\n'
-    res += '     {}\n'.format(ITAX_MTR_BIN_EDGES)
+    res += f'     {ITAX_MTR_BIN_EDGES}\n'
     variable_header = 'PTAX and ITAX mtr histogram bin counts for'
     # compute marginal tax rate (mtr) histograms for each mtr variable
     for var_str in Calculator.MTR_VALID_VARIABLES:
-        zero_out = (var_str == 'e01400')
+        zero_out = var_str == 'e01400'
         (mtr_ptax, mtr_itax, _) = calc.mtr(variable_str=var_str,
                                            negative_finite_diff=MTR_NEG_DIFF,
                                            zero_out_calculated_vars=zero_out,
@@ -250,17 +250,17 @@ def test_mtr(tests_path, puf_path):
             # only MARS==2 filing units have valid MTR values
             mtr_ptax = mtr_ptax[calc.array('MARS') == 2]
             mtr_itax = mtr_itax[calc.array('MARS') == 2]
-        res += '{} {}:\n'.format(variable_header, var_str)
+        res += f'{variable_header} {var_str}:\n'
         res += mtr_bin_counts(mtr_ptax, PTAX_MTR_BIN_EDGES, recid)
         res += mtr_bin_counts(mtr_itax, ITAX_MTR_BIN_EDGES, recid)
     # check for differences between actual and expected results
     mtrres_path = os.path.join(tests_path, 'pufcsv_mtr_expect.txt')
-    with open(mtrres_path, 'r') as expected_file:
+    with open(mtrres_path, 'r', encoding='utf-8') as expected_file:
         txt = expected_file.read()
     expected_results = txt.rstrip('\n\t ') + '\n'  # cleanup end of file txt
     if nonsmall_diffs(res.splitlines(True), expected_results.splitlines(True)):
-        new_filename = '{}{}'.format(mtrres_path[:-10], 'actual.txt')
-        with open(new_filename, 'w') as new_file:
+        new_filename = f'{mtrres_path[:-10]}actual.txt'
+        with open(new_filename, 'w', encoding='utf-8') as new_file:
             new_file.write(res)
         msg = 'PUFCSV MTR RESULTS DIFFER\n'
         msg += '-------------------------------------------------\n'
@@ -372,7 +372,7 @@ def test_puf_availability(tests_path, puf_path):
     pufvars = set(list(pufdf))
     # make set of variable names that are marked as puf.csv available
     rvpath = os.path.join(tests_path, '..', 'records_variables.json')
-    with open(rvpath, 'r') as rvfile:
+    with open(rvpath, 'r', encoding='utf-8') as rvfile:
         rvdict = json.load(rvfile)
     recvars = set()
     for vname, vdict in rvdict['read'].items():

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
@@ -383,4 +386,4 @@ def test_ext_reform(tests_path):
     iitax_ext = calc_ext.array('iitax')
     rdiff = iitax_ext - iitax_end
     weighted_sum_rdiff = (rdiff * calc_end.array('s006')).sum() * 1.0e-9
-    assert np.allclose([weighted_sum_rdiff], [-215.659], rtol=0.0, atol=0.01)
+    assert np.allclose([weighted_sum_rdiff], [-214.11], rtol=0.0, atol=0.01)

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