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

taxcalc/tests/test_parameters.py

@@ -13,15 +13,11 @@ import tempfile
 import numpy as np
 import paramtools
 import pytest
-# pylint: disable=import-error
-from taxcalc import (
-    Parameters,
-    Policy,
-    Consumption,
-    GrowDiff,
-    GrowFactors,
-    is_paramtools_format,
-)
+from taxcalc.parameters import Parameters, is_paramtools_format
+from taxcalc.policy import Policy
+from taxcalc.consumption import Consumption
+from taxcalc.growdiff import GrowDiff
+from taxcalc.growfactors import GrowFactors
 
 
 # Test specification and use of simple Parameters-derived class that has
@@ -129,6 +125,7 @@ def test_params_class(revision, expect, params_json_file):
         """
         The Params class is derived from the abstract base Parameter class.
         """
+        # pylint: disable=too-few-public-methods,abstract-method
         DEFAULTS_FILE_NAME = params_json_file.name
         DEFAULTS_FILE_PATH = ''
         START_YEAR = 2001
@@ -157,8 +154,8 @@ def test_params_class(revision, expect, params_json_file):
         assert prms.start_year == 2001
         assert prms.current_year == 2001
         assert prms.end_year == 2010
-        assert prms.inflation_rates() == list()
-        assert prms.wage_growth_rates() == list()
+        assert prms.inflation_rates() == []
+        assert prms.wage_growth_rates() == []
         prms.set_year(2010)
         assert prms.current_year == 2010
         with pytest.raises(paramtools.ValidationError):
@@ -189,24 +186,17 @@ def test_json_file_contents(tests_path, fname):
     """
     Check contents of JSON parameter files in Tax-Calculator/taxcalc directory.
     """
+    # pylint: disable=too-many-locals,too-many-branches
     first_year = Policy.JSON_START_YEAR
     last_known_year = Policy.LAST_KNOWN_YEAR  # for indexed parameter values
     known_years = set(range(first_year, last_known_year + 1))
-    long_params = ['II_brk1', 'II_brk2', 'II_brk3', 'II_brk4',
-                   'II_brk5', 'II_brk6', 'II_brk7',
-                   'PT_brk1', 'PT_brk2', 'PT_brk3', 'PT_brk4',
-                   'PT_brk5', 'PT_brk6', 'PT_brk7',
-                   'PT_qbid_taxinc_thd',
-                   'ALD_BusinessLosses_c',
-                   'STD', 'II_em', 'II_em_ps',
-                   'AMT_em', 'AMT_em_ps', 'AMT_em_pe',
-                   'ID_ps', 'ID_AllTaxes_c']
     # for TCJA-reverting long_params
     long_known_years = set(range(first_year, last_known_year + 1))
     long_known_years.add(2026)
     # check elements in each parameter sub-dictionary
     failures = ''
-    with open(os.path.join(tests_path, "..", fname)) as f:
+    path = os.path.join(tests_path, "..", fname)
+    with open(path, 'r', encoding='utf-8') as f:
         allparams = json.loads(f.read())
     for pname in allparams:
         if pname == "schema":
@@ -219,24 +209,29 @@ def test_json_file_contents(tests_path, fname):
             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):
-            msg = 'param:<{}>; indexed={}; indexable={}'
-            fail = msg.format(pname,
-                              param.get('indexed', False),
-                              param.get('indexable', False))
-            failures += fail + '\n'
+            msg = (
+                f'param:<{pname}>; '
+                f'indexed={param.get("indexed", False)}; '
+                f'indexable={param.get("indexable", False)}\n'
+            )
+            failures += msg
         # check that indexable param has value_type float
         if param.get('indexable', False) and param['type'] != 'float':
-            msg = 'param:<{}>; type={}; indexable={}'
-            fail = msg.format(pname, param['type'],
-                              param.get('indexable', False))
-            failures += fail + '\n'
+            msg = (
+                f'param:<{pname}>; '
+                f'type={param["type"]}; '
+                f'indexable={param.get("indexable", False)}\n'
+            )
+            failures += msg
         # ensure that indexable is False when value_type is not real
         if param.get('indexable', False) and param['type'] != 'float':
-            msg = 'param:<{}>; indexable={}; type={}'
-            fail = msg.format(pname,
-                              param.get('indexable', False),
-                              param['value_type'])
-            failures += fail + '\n'
+            msg = (
+                f'param:<{pname}>; '
+                f'indexable={param.get("indexable", False)}; '
+                f'type={param["value_type"]}\n'
+            )
+            failures += msg
+    o = None
     if fname == "consumption.json":
         o = Consumption()
     elif fname == "policy_current_law.json":
@@ -251,9 +246,8 @@ 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 = 'param:<{}>; not found in year={}'
-                fail = msg.format(param, y)
-                failures += fail + '\n'
+                msg = f'param:<{param}>; not found in year={y}\n'
+                failures += msg
     if failures:
         raise ValueError(failures)
 
@@ -268,29 +262,29 @@ def test_parameters_mentioned(tests_path, jfname, pfname):
     """
     # read JSON parameter file into a dictionary
     path = os.path.join(tests_path, '..', jfname)
-    pfile = open(path, 'r')
-    allparams = json.load(pfile)
-    pfile.close()
+    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':
         # consumption.py does not explicitly name the parameters
         code_text = ''
         for var in Consumption.RESPONSE_VARS:
-            code_text += 'MPC_{}\n'.format(var)
+            code_text += f'MPC_{var}\n'
         for var in Consumption.BENEFIT_VARS:
-            code_text += 'BEN_{}_value\n'.format(var)
+            code_text += f'BEN_{var}_value\n'
     elif pfname == 'growdiff.py':
         # growdiff.py does not explicitly name the parameters
         code_text = ''
         for var in GrowFactors.VALID_NAMES:
-            code_text += '{}\n'.format(var)
+            code_text += f'{var}\n'
     else:
         # parameters are explicitly named in PYTHON file
         path = os.path.join(tests_path, '..', pfname)
-        pfile = open(path, 'r')
-        code_text = pfile.read()
-        pfile.close()
+        with open(path, 'r', encoding='utf-8') as pfile:
+            code_text = pfile.read()
+    # pylint: enable=consider-using-join
     # check that each param (without leading _) is mentioned in code text
     for pname in allparams:
         if pname == "schema":
@@ -301,6 +295,7 @@ def test_parameters_mentioned(tests_path, jfname, pfname):
 # following tests access private methods, so pylint: disable=protected-access
 
 class ArrayParams(Parameters):
+    """ArrayParams class"""
     defaults = {
         "schema": {
             "labels": {
@@ -407,7 +402,7 @@ class ArrayParams(Parameters):
         self._update(revision, print_warnings, raise_errors)
 
     def set_rates(self):
-        pass
+        """Method docstring"""
 
 
 def test_expand_xd_errors():
@@ -420,6 +415,7 @@ def test_expand_xd_errors():
 
 
 def test_expand_empty():
+    """Test docstring"""
     params = ArrayParams(label_to_extend=None, array_first=False)
     params.sort_values()
     one_dim = copy.deepcopy(params.one_dim)
@@ -431,6 +427,7 @@ def test_expand_empty():
 
 
 def test_expand_1d_scalar():
+    """Test docstring"""
     yrs = 12
     val = 10.0
     exp = np.array([val * math.pow(1.02, i) for i in range(0, yrs)])
@@ -453,7 +450,6 @@ def test_expand_2d_short_array():
     """
     One of several _expand_?D tests.
     """
-    ary = np.array([[1., 2., 3.]])
     val = np.array([1., 2., 3.])
     exp2 = np.array([val * math.pow(1.02, i) for i in range(1, 5)])
     exp1 = np.array([1., 2., 3.])
@@ -563,19 +559,19 @@ def test_expand_2d_partial_expand():
     assert np.allclose(res, exp, atol=0.01, rtol=0.0)
 
 
-taxcalc_revision = """
+TAXCALC_REVISION = """
 {
     "consumption": {"BEN_mcaid_value": {"2013": 0.9}}
 }
 """
 
-paramtools_revision = """
+PARAMTOOLS_REVISION = """
 {
     "consumption": {"BEN_mcaid_value": [{"year": "2013", "value": 0.9}]}
 }
 """
 
-paramtools_revision2 = """
+PARAMTOOLS_REVISION2 = """
 {
     "consumption": {"BEN_mcaid_value": 0.9}
 }
@@ -583,8 +579,8 @@ paramtools_revision2 = """
 
 
 @pytest.mark.parametrize("good_revision", [
-    taxcalc_revision,
-    paramtools_revision,
+    TAXCALC_REVISION,
+    PARAMTOOLS_REVISION,
 ])
 def test_read_json_revision(good_revision):
     """
@@ -593,7 +589,7 @@ 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(list(), '')
+        Parameters._read_json_revision([], '')
     with pytest.raises(ValueError):
         # error because second topkey argument must be a string
         Parameters._read_json_revision(good_revision, 999)
@@ -603,9 +599,9 @@ def test_read_json_revision(good_revision):
 
 
 @pytest.mark.parametrize("params,is_paramtools", [
-    (taxcalc_revision, False),
-    (paramtools_revision, True),
-    (paramtools_revision2, True),
+    (TAXCALC_REVISION, False),
+    (PARAMTOOLS_REVISION, True),
+    (PARAMTOOLS_REVISION2, True),
 ])
 def test_read_json_revision_foramts(params, is_paramtools):
     """

taxcalc/tests/test_policy.py

@@ -13,8 +13,7 @@ import json
 import numpy as np
 import pytest
 import paramtools as pt
-# pylint: disable=import-error
-from taxcalc import Policy
+from taxcalc.policy import Policy
 
 
 def cmp_policy_objs(pol1, pol2, year_range=None, exclude=None):
@@ -30,7 +29,7 @@ def cmp_policy_objs(pol1, pol2, year_range=None, exclude=None):
     else:
         pol1.clear_state()
         pol2.clear_state()
-    for param in pol1._data:
+    for param in pol1._data:  # pylint: disable=protected-access
         if exclude and param in exclude:
             continue
         v1 = getattr(pol1, param)
@@ -562,7 +561,7 @@ def test_order_of_indexing_and_level_reforms():
     make no difference to the post-reform policy parameter values.
     """
     # specify two reforms that raises the MTE and stops its indexing in 2015
-    reform = [
+    reforms = [
         {
             'SS_Earnings_c': {2015: 500000},
             'SS_Earnings_c-indexed': {2015: False}
@@ -577,17 +576,17 @@ def test_order_of_indexing_and_level_reforms():
     ppo = [Policy(), Policy()]
     # apply reforms to corresponding Policy object & check post-reform values
     syr = Policy.JSON_START_YEAR
-    for ref in range(len(reform)):  # pylint: disable=consider-using-enumerate
+    for idx, reform in enumerate(reforms):
         # confirm pre-reform MTE values in 2014-2017
-        mte = ppo[ref]._SS_Earnings_c
+        mte = ppo[idx]._SS_Earnings_c
         assert mte[2014 - syr] == 117000
         assert mte[2015 - syr] == 118500
         assert mte[2016 - syr] == 118500
         assert mte[2017 - syr] < 500000
         # implement reform in 2015
-        ppo[ref].implement_reform(reform[ref])
+        ppo[idx].implement_reform(reform)
         # confirm post-reform MTE values in 2014-2017
-        mte = ppo[ref]._SS_Earnings_c
+        mte = ppo[idx]._SS_Earnings_c
         assert mte[2014 - syr] == 117000
         assert mte[2015 - syr] == 500000
         assert mte[2016 - syr] == 500000
@@ -765,7 +764,7 @@ def test_section_titles(tests_path):
         md_text = md_file.read()
     md_dict = generate_section_dictionary(md_text)
     # ... make sure every md_dict section title is in valid_dict
-    for sec1title,secdict in md_dict.items():
+    for sec1title, secdict in md_dict.items():
         assert isinstance(secdict, dict)
         assert sec1title in valid_dict
         for sec2title in secdict:
@@ -1332,7 +1331,7 @@ def test_multiple_cpi_swaps2():
                 {"year": 2018, "value": 500000},
             ],
             "SS_Earnings_c-indexed": [
-                    {"year": 2017, "value": False},
+                {"year": 2017, "value": False},
                 {"year": 2019, "value": True},
             ],
             "AMT_em-indexed": [
@@ -1417,6 +1416,9 @@ def test_multiple_cpi_swaps2():
     )
 
 
+# pylint: disable=invalid-name
+
+
 def test_adj_CPI_offset_and_index_status():
     """
     Test changing parameter_indexing_CPI_offset and another
@@ -1540,8 +1542,8 @@ def test_two_sets_of_tax_brackets():
     Test that II_brk? and PT_brk? values are the same under current law.
     """
     pol = Policy()
-    brackets = range(1, 7+1)
-    years = range(Policy.JSON_START_YEAR, Policy.LAST_KNOWN_YEAR+1)
+    brackets = range(1, 7 + 1)
+    years = range(Policy.JSON_START_YEAR, Policy.LAST_KNOWN_YEAR + 1)
     emsg = ''
     for year in years:
         pol.set_year(year)

taxcalc/tests/test_puf_var_stats.py

@@ -11,8 +11,9 @@ import copy
 import numpy as np
 import pandas as pd
 import pytest
-# 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
 
 
 def create_base_table(test_path):
@@ -60,10 +61,10 @@ def create_base_table(test_path):
     read_vars = list(records_varinfo.USABLE_READ_VARS - unused_var_set)
     # get read variable information from JSON file
     rec_vars_path = os.path.join(test_path, '..', 'records_variables.json')
-    with open(rec_vars_path) as rvfile:
+    with open(rec_vars_path, 'r', encoding='utf-8') as rvfile:
         read_var_dict = json.load(rvfile)
     # create table_dict with sorted read vars followed by sorted calc vars
-    table_dict = dict()
+    table_dict = {}
     for var in sorted(read_vars):
         if "taxdata_puf" in read_var_dict['read'][var]['availability']:
             table_dict[var] = read_var_dict['read'][var]['desc']
@@ -85,14 +86,14 @@ def calculate_corr_stats(calc, table):
     errmsg = ''
     for varname1 in table.index:
         var1 = calc.array(varname1)
-        var1_cc = list()
+        var1_cc = []
         for varname2 in table.index:
             var2 = calc.array(varname2)
             try:
                 cor = np.corrcoef(var1, var2)[0][1]
             except FloatingPointError:
-                msg = 'corr-coef error for {} and {}\n'
-                errmsg += msg.format(varname1, varname2)
+                msg = f'corr-coef error for {varname1} and {varname2}\n'
+                errmsg += msg
                 cor = 9.99  # because could not compute it
             var1_cc.append(cor)
         table[varname1] = var1_cc
@@ -105,7 +106,7 @@ def calculate_mean_stats(calc, table, year):
     Calculate weighted means for year.
     """
     total_weight = calc.total_weight()
-    means = list()
+    means = []
     for varname in table.index:
         wmean = calc.weighted_total(varname) / total_weight
         means.append(wmean)
@@ -131,14 +132,13 @@ def differences(new_filename, old_filename, stat_kind):
     if diffs:
         new_name = os.path.basename(new_filename)
         old_name = os.path.basename(old_filename)
-        msg = '{} RESULTS DIFFER:\n'.format(stat_kind)
+        msg = f'{stat_kind} RESULTS DIFFER:\n'
         msg += '-------------------------------------------------'
         msg += '-------------\n'
-        msg += '--- NEW RESULTS IN {} FILE ---\n'.format(new_name)
-        msg += '--- if new OK, copy {} to  ---\n'.format(new_name)
-        msg += '---                 {}         ---\n'.format(old_name)
-        msg += '---            and rerun test.                   '
-        msg += '          ---\n'
+        msg += f'--- NEW RESULTS IN {new_name} FILE ---\n'
+        msg += f'--- if new OK, copy {new_name} to\n'
+        msg += f'---                 {old_name}   \n'
+        msg += '---            and rerun test.      '
         msg += '-------------------------------------------------'
         msg += '-------------\n'
     else:

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():