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

taxcalc/__init__.py

@@ -14,6 +14,6 @@ from taxcalc.taxcalcio import *
 from taxcalc.utils import *
 from taxcalc.cli import *
 
-__version__ = '4.5.0'
+__version__ = '4.6.1'
 __min_python3_version__ = 10
 __max_python3_version__ = 12

taxcalc/calcfunctions.py

@@ -3,11 +3,7 @@ Tax-Calculator functions that calculate payroll and individual income taxes.
 
 These functions are imported into the Calculator class.
 
-Note: the parameter_indexing_CPI_offset policy parameter is the only
-policy parameter that does not appear here; it is used in the policy.py
-file to possibly adjust the price inflation rate used to index policy
-parameters (as would be done in a reform that introduces chained-CPI
-indexing).
+Note: the parameter_indexing_CPI_offset parameter is no longer used.
 """
 # CODING-STYLE CHECKS:
 # pycodestyle calcfunctions.py
@@ -2059,7 +2055,7 @@ def AMT(e07300, dwks13, standard, f6251, c00100, c18300, taxbc,
     e62900: float
         Alternative Minimum Tax foreign tax credit from Form 6251
     e00700: float
-        Schedule C business net profit/loss for filing unit
+        Taxable refunds of state and local income taxes
     dwks10: float
         Sum of dwks6 + dwks9
     age_head: int

taxcalc/calculator.py

@@ -113,29 +113,29 @@ class Calculator():
             raise ValueError('consumption must be None or Consumption object')
         if self.__consumption.current_year < self.__policy.current_year:
             self.__consumption.set_year(self.__policy.current_year)
-        if verbose:
-            if self.__records.IGNORED_VARS:
-                print('Your data include the following unused ' +
-                      'variables that will be ignored:')
-                for var in self.__records.IGNORED_VARS:
-                    print('  ' +
-                          var)
         current_year_is_data_year = (
             self.__records.current_year == self.__records.data_year)
         if sync_years and current_year_is_data_year:
-            if verbose:
-                print('You loaded data for ' +
-                      str(self.__records.data_year) + '.')
             while self.__records.current_year < self.__policy.current_year:
                 self.__records.increment_year()
             if verbose:
-                print('Tax-Calculator startup automatically ' +
-                      'extrapolated your data to ' +
-                      str(self.__records.current_year) + '.')
+                print(
+                    f'Read input data for {self.__records.data_year}; '
+                    'input data were extrapolated to '
+                    f'{self.__records.current_year}'
+                )
         else:
             if verbose:
-                print('Tax-Calculator startup did not ' +
-                      'extrapolate your data.')
+                print(  # pragma: no cover
+                    'Read input data that were not extrapolated in any way'
+                )
+        if verbose and self.__records.IGNORED_VARS:  # pragma: no cover
+            print(
+                'Input data include the following unused '
+                'variables that will be ignored:'
+            )
+            for var in self.__records.IGNORED_VARS:
+                print(f'  {var}')
         assert self.__policy.current_year == self.__records.current_year
         assert self.__policy.current_year == self.__consumption.current_year
         self.__stored_records = None
@@ -305,11 +305,11 @@ class Calculator():
         return self.__consumption.benval_params()
 
     @property
-    def reform_warnings(self):
+    def reform_errors(self):
         """
-        Calculator class embedded Policy object's parameter_warnings.
+        Calculator class embedded Policy object's parameter_errors.
         """
-        return self.__policy.parameter_warnings
+        return self.__policy.parameter_errors
 
     @property
     def current_year(self):

taxcalc/cli/tc.py

@@ -1,6 +1,6 @@
 """
 Command-line interface (CLI) to Tax-Calculator,
-which can be accessed as 'tc' from an installed taxcalc conda package.
+which can be accessed as 'tc' from an installed taxcalc package.
 """
 # CODING-STYLE CHECKS:
 # pycodestyle tc.py
@@ -9,6 +9,7 @@ which can be accessed as 'tc' from an installed taxcalc conda package.
 import os
 import sys
 import time
+import sqlite3
 import argparse
 import difflib
 import taxcalc as tc
@@ -25,26 +26,31 @@ def cli_tc_main():
     # pylint: disable=too-many-statements,too-many-branches
     # pylint: disable=too-many-return-statements,too-many-locals
 
+    start_time = time.time()
+
     # parse command-line arguments:
-    usage_str = 'tc INPUT TAXYEAR {}{}{}{}{}'.format(
-        '[--help]\n',
-        ('          '
-         '[--baseline BASELINE] [--reform REFORM] [--assump  ASSUMP]\n'),
-        ('          '
-         '[--exact] [--tables] [--graphs] [--timings]\n'),
-        ('          '
-         '[--dump] [--dvars DVARS] [--sqldb] [--outdir OUTDIR]\n'),
-        ('          '
-         '[--test] [--version]'))
+    usage_str = 'tc INPUT TAXYEAR {}{}{}{}'.format(
+        '[--help] [--numyears N]\n',
+        (
+            '          '
+            '[--baseline BASELINE] [--reform REFORM] '
+            '[--assump ASSUMP] [--exact]\n'
+        ),
+        (
+            '          '
+            '[--params] [--tables] [--graphs] '
+            '[--dumpdb] [--dumpvars DUMPVARS]\n'
+        ),
+        (
+            '          '
+            '[--silent] [--test] [--version] [--usage]'
+        )
+    )
     parser = argparse.ArgumentParser(
         prog='',
         usage=usage_str,
-        description=('Writes to a file the federal income and payroll tax '
-                     'OUTPUT for each filing unit specified in the INPUT '
-                     'file, with the OUTPUT computed from the INPUT for the '
-                     'TAXYEAR using Tax-Calculator. The OUTPUT file is a '
-                     'CSV-formatted file that contains tax information for '
-                     'each INPUT filing unit under the reform(s).'))
+        description=('Writes several output files computed from the INPUT '
+                     'for the TAXYEAR using Tax-Calculator.'))
     parser.add_argument('INPUT', nargs='?',
                         help=('INPUT is name of CSV-formatted file that '
                               'contains for each filing unit variables used '
@@ -57,16 +63,27 @@ def cli_tc_main():
                               'are computed.'),
                         type=int,
                         default=0)
+    parser.add_argument('--numyears', metavar='N',
+                        help=('N is an integer indicating for how many '
+                              'years taxes are calculated. No --numyears '
+                              'implies calculations are done only for '
+                              'TAXYEAR. N greater than one implies output '
+                              'is written to separate files for each year '
+                              'beginning with TAXYEAR.'),
+                        type=int,
+                        default=1)
     parser.add_argument('--baseline',
                         help=('BASELINE is name of optional JSON reform file. '
+                              'A compound reform can be specified using 2+ '
+                              'file names separated by plus (+) character(s). '
                               'No --baseline implies baseline policy is '
                               'current-law policy.'),
                         default=None)
     parser.add_argument('--reform',
                         help=('REFORM is name of optional JSON reform file. '
-                              'A compound reform can be specified using two '
-                              'file names separated by a plus (+) character. '
-                              'No --reform implies a "null" reform (that is, '
+                              'A compound reform can be specified using 2+ '
+                              'file names separated by plus (+) character(s). '
+                              'No --reform implies reform policy is '
                               'current-law policy).'),
                         default=None)
     parser.add_argument('--assump',
@@ -80,6 +97,12 @@ def cli_tc_main():
                               'complicate marginal-tax-rate calculations.'),
                         default=False,
                         action="store_true")
+    parser.add_argument('--params',
+                        help=('optional flag that causes policy parameter '
+                              'values for baseline and reform to be written '
+                              'to separate text files.'),
+                        default=False,
+                        action="store_true")
     parser.add_argument('--tables',
                         help=('optional flag that causes distributional '
                               'tables to be written to a text file.'),
@@ -90,47 +113,33 @@ def cli_tc_main():
                               'to HTML files for viewing in browser.'),
                         default=False,
                         action="store_true")
-    parser.add_argument('--timings',
-                        help=('optional flag that causes execution times to '
-                              'be written to stdout.'),
-                        default=False,
-                        action="store_true")
-    parser.add_argument('--dump',
-                        help=('optional flag that causes OUTPUT to contain '
-                              'all INPUT variables (extrapolated to TAXYEAR) '
-                              'and all calculated tax variables for the '
-                              'reform, where all the variables are named '
-                              'using their internal Tax-Calculator names. '
-                              'No --dump option implies OUTPUT contains '
-                              'minimal tax output for the reform.  NOTE: '
-                              'use the --dvars option to point to a file '
-                              'containing a custom set of dump variables.'
-                              ''),
+    parser.add_argument('--dumpdb',
+                        help=('optional flag that causes TAXYEAR variable '
+                              'values for each tax-unit under both '
+                              'baseline and reform policies to be written '
+                              'to a SQLite database (where the variables '
+                              'included in the database are controlled by '
+                              'the --dumpvars option).'),
                         default=False,
                         action="store_true")
-    parser.add_argument('--dvars',
-                        help=('DVARS is name of optional file containing a '
+    parser.add_argument('--dumpvars',
+                        help=('DUMPVARS is name of optional file containing a '
                               'space-delimited list of variables to include '
-                              'in a partial dump OUTPUT file.  No --dvars '
-                              'implies a full dump containing all variables.'),
+                              'in the dump database.  No --dumpvars '
+                              'implies a minimal set of variables.  Valid '
+                              'variable names include all variables in the '
+                              'records_variables.json file plus mtr_itax and '
+                              'mtr_ptax (MTRs wrt taxpayer earnings).'),
                         default=None)
-    parser.add_argument('--sqldb',
-                        help=('optional flag that writes SQLite database '
-                              'with two tables (baseline and reform) each '
-                              'containing same output variables as '
-                              'produced by --dump option.'),
+    parser.add_argument('--silent',
+                        help=('optional flag that suppresses messages about '
+                              'input and output actions.'),
                         default=False,
                         action="store_true")
-    parser.add_argument('--outdir',
-                        help=('OUTDIR is name of optional output directory '
-                              'in which all output files are written. '
-                              'No --outdir implies output files are written '
-                              'in the current directory.'),
-                        default=None)
     parser.add_argument('--test',
                         help=('optional flag that conducts installation '
                               'test, writes test result to stdout, '
-                              'and quits.'),
+                              'and quits leaving the test-related files.'),
                         default=False,
                         action="store_true")
     parser.add_argument('--version',
@@ -138,6 +147,11 @@ def cli_tc_main():
                               'release version to stdout and quits.'),
                         default=False,
                         action="store_true")
+    parser.add_argument('--usage',
+                        help=('optional flag that writes short usage '
+                              'reminder to stdout and quits.'),
+                        default=False,
+                        action="store_true")
     args = parser.parse_args()
     # check Python version
     pyv = sys.version_info
@@ -155,109 +169,228 @@ def cli_tc_main():
         pyver = f'Python 3.{pyv[1]}'
         sys.stdout.write(f'Tax-Calculator {tc.__version__} on {pyver}\n')
         return 0
+    # show short usage reminder and quit if --usage option is specified
+    if args.usage:
+        sys.stdout.write(f'USAGE: {usage_str}\n')
+        return 0
     # write test input and expected output files if --test option is specified
     if args.test:
-        _write_expected_test_output()
+        _write_test_files()
         inputfn = TEST_INPUT_FILENAME
         taxyear = TEST_TAXYEAR
+        args.numyears = 1
+        args.dumpdb = True
     else:
         inputfn = args.INPUT
         taxyear = args.TAXYEAR
-    # instantiate TaxCalcIO object and do tax analysis
-    tcio = tc.TaxCalcIO(input_data=inputfn, tax_year=taxyear,
-                        baseline=args.baseline,
-                        reform=args.reform, assump=args.assump,
-                        outdir=args.outdir)
-    if tcio.errmsg:
-        sys.stderr.write(tcio.errmsg)
+    # check taxyear value
+    if taxyear > tc.Policy.LAST_BUDGET_YEAR:
+        msg = f'ERROR: TAXYEAR is greater than {tc.Policy.LAST_BUDGET_YEAR}\n'
+        sys.stderr.write(msg)
+        sys.stderr.write('USAGE: tc --help\n')
+        return 1
+    # check numyears value
+    if args.numyears < 1:
+        msg = 'ERROR: --numyears parameter N is less than one\n'
+        sys.stderr.write(msg)
         sys.stderr.write('USAGE: tc --help\n')
         return 1
-    aging = (
+    max_numyears = tc.Policy.LAST_BUDGET_YEAR - taxyear + 1
+    if args.numyears > max_numyears:
+        msg = f'ERROR: --numyears parameter N is greater than {max_numyears}\n'
+        sys.stderr.write(msg)
+        sys.stderr.write('USAGE: tc --help\n')
+        return 1
+    # specify if aging input data
+    aging_data = (
         inputfn.endswith('puf.csv') or
         inputfn.endswith('cps.csv') or
         inputfn.endswith('tmd.csv')
     )
-    if args.timings:
-        stime = time.time()
-    tcio.init(input_data=inputfn, tax_year=taxyear,
-              baseline=args.baseline,
-              reform=args.reform, assump=args.assump,
-              aging_input_data=aging,
-              exact_calculations=args.exact)
-    if args.timings:
-        xtime = time.time() - stime
-        sys.stdout.write(f'TIMINGS: init time = {xtime:.2f} secs\n')
-    if tcio.errmsg:
-        sys.stderr.write(tcio.errmsg)
+    # check args.dumpdb and args.dumpvars consistency
+    if not args.dumpdb and args.dumpvars:
+        msg = 'ERROR: DUMPVARS file specified without --dumpdb option\n'
+        sys.stderr.write(msg)
         sys.stderr.write('USAGE: tc --help\n')
         return 1
-    dumpvar_set = None
-    if args.dvars and (args.dump or args.sqldb):
-        if os.path.exists(args.dvars):
-            with open(args.dvars, 'r', encoding='utf-8') as dfile:
-                dump_vars_str = dfile.read()
-            dumpvar_set = tcio.custom_dump_variables(dump_vars_str)
-            if tcio.errmsg:
-                sys.stderr.write(tcio.errmsg)
-                sys.stderr.write('USAGE: tc --help\n')
-                return 1
+    # specify dumpvars_str from args.dumpvars file
+    dumpvars_str = ''
+    if args.dumpvars:
+        if os.path.exists(args.dumpvars):
+            with open(args.dumpvars, 'r', encoding='utf-8') as dfile:
+                dumpvars_str = dfile.read()
         else:
-            msg = 'ERROR: DVARS file {} does not exist\n'
-            sys.stderr.write(msg.format(args.dvars))
+            msg = f'ERROR: DUMPVARS file {args.dumpvars} does not exist\n'
+            sys.stderr.write(msg)
             sys.stderr.write('USAGE: tc --help\n')
             return 1
-    # conduct tax analysis
-    if args.timings:
-        stime = time.time()
-    tcio.analyze(writing_output_file=True,
-                 output_tables=args.tables,
-                 output_graphs=args.graphs,
-                 dump_varset=dumpvar_set,
-                 output_dump=args.dump,
-                 output_sqldb=args.sqldb)
-    if args.timings:
-        xtime = time.time() - stime
-        sys.stdout.write(f'TIMINGS: calc time = {xtime:.2f} secs\n')
+    # do calculations for taxyear
+    # ... initialize TaxCalcIO object for taxyear
+    tcio = tc.TaxCalcIO(
+        input_data=inputfn,
+        tax_year=taxyear,
+        baseline=args.baseline,
+        reform=args.reform,
+        assump=args.assump,
+        silent=args.silent,
+    )
+    if tcio.errmsg:
+        if tcio.errmsg.endswith('\n'):
+            sys.stderr.write(tcio.errmsg)
+        else:
+            sys.stderr.write(tcio.errmsg + '\n')
+        sys.stderr.write('USAGE: tc --help\n')
+        return 1
+    tcio.init(
+        input_data=inputfn,
+        tax_year=taxyear,
+        baseline=args.baseline,
+        reform=args.reform,
+        assump=args.assump,
+        aging_input_data=aging_data,
+        exact_calculations=args.exact,
+    )
+    if tcio.errmsg:
+        if tcio.errmsg.endswith('\n'):
+            sys.stderr.write(tcio.errmsg)
+        else:
+            sys.stderr.write(tcio.errmsg + '\n')
+        sys.stderr.write('USAGE: tc --help\n')
+        return 1
+    # ... conduct tax analysis for taxyear
+    dumpvars_list = tcio.dump_variables(dumpvars_str)
+    if tcio.errmsg:
+        if tcio.errmsg.endswith('\n'):
+            sys.stderr.write(tcio.errmsg)
+        else:
+            sys.stderr.write(tcio.errmsg + '\n')
+            sys.stderr.write('USAGE: tc --help\n')
+        return 1
+    tcio.analyze(
+        output_params=args.params,
+        output_tables=args.tables,
+        output_graphs=args.graphs,
+        output_dump=args.dumpdb,
+        dump_varlist=dumpvars_list,
+    )
     # compare test output with expected test output if --test option specified
     if args.test:
         retcode = _compare_test_output_files()
         return retcode
+    # quit if args.numyears is equal to one
+    if args.numyears == 1:
+        if not args.silent:
+            print(  # pragma: no cover
+                f'Execution time is {(time.time() - start_time):.1f} seconds'
+            )
+        return 0
+    # analyze years after taxyear if args.numyears is greater than one
+    for xyear in range(1, args.numyears):
+        tcio.advance_to_year(taxyear + xyear, aging_data)
+        tcio.analyze(
+            output_params=args.params,
+            output_tables=args.tables,
+            output_graphs=args.graphs,
+            output_dump=args.dumpdb,
+            dump_varlist=dumpvars_list,
+        )
+    if not args.silent:
+        print(  # pragma: no cover
+            f'Execution time is {(time.time() - start_time):.1f} seconds'
+        )
     return 0
 # end of cli_tc_main function code
 
 
-EXPECTED_TEST_OUTPUT_FILENAME = f'test-{str(TEST_TAXYEAR)[2:]}-out.csv'
-ACTUAL_TEST_OUTPUT_FILENAME = f'test-{str(TEST_TAXYEAR)[2:]}-#-#-#.csv'
+TEST_INPUT_DATA = (
+    'RECID,MARS,XTOT,EIC,e00200,e00200p,e00200s,p23250,e18400,e19800,s006\n'
+    '1,       2,   3,  1, 40000,  40000,      0,     0,  3000,  4000, 1e7\n'
+    '2,       2,   3,  1,200000, 200000,      0,     0, 15000, 20000, 1e7\n'
+)
+EXPECTED_TEST_FILENAME = f'test-{str(TEST_TAXYEAR)[2:]}.exp'
+EXPECTED_TEST_OUTPUT = (
+    'id|itax\n'
+    '1|131.88\n'
+    '2|28879.00\n'
+)
+TEST_DUMPDB_FILENAME = f'test-{str(TEST_TAXYEAR)[2:]}-#-#-#.db'
+TEST_SQLITE_QUERY = """
+SELECT
+  RECID           AS id,
+  ROUND(iitax, 2) AS itax
+FROM baseline;
+"""
+ACTUAL_TEST_FILENAME = f'test-{str(TEST_TAXYEAR)[2:]}.act'
+TEST_TABULATE_FILENAME = 'test-tabulate.sql'
+TEST_TABULATE_SQLCODE = (
+    f'-- USAGE: sqlite3 {TEST_DUMPDB_FILENAME} < {TEST_TABULATE_FILENAME}\n'
+    '\n'
+    '-- sepecify base.income_group values\n'
+    'UPDATE base SET income_group =\n'
+    '  CASE  -- specify the income_group brackets as desired\n'
+    '    WHEN expanded_income <   0.0   THEN 0\n'
+    '    WHEN expanded_income <  50.0e3 THEN 1\n'
+    '    WHEN expanded_income < 100.0e3 THEN 2\n'
+    '    WHEN expanded_income < 500.0e3 THEN 3\n'
+    '    WHEN expanded_income <   1.0e6 THEN 4\n'
+    '    ELSE                                5\n'
+    '  END;\n'
+    '\n'
+    '-- tabulate baseline and reform iitax for joint filers by income_group\n'
+    '.separator "\t"\n'
+    '.headers on\n'
+    'SELECT\n'
+    '  income_group                     AS g,\n'
+    '  COUNT(*)                         AS units,\n'
+    '  ROUND(SUM(b.iitax*s006)*1e-9, 3) AS b_iitax,\n'
+    '  ROUND(SUM(r.iitax*s006)*1e-9, 3) AS r_iitax\n'
+    'FROM base JOIN baseline AS b USING(RECID) JOIN reform AS r USING(RECID)\n'
+    'WHERE MARS == 2\n'
+    'GROUP BY income_group;\n'
+    '.headers off\n'
+    'SELECT\n'
+    "  'A'                              AS g,\n"
+    '  COUNT(*)                         AS units,\n'
+    '  ROUND(SUM(b.iitax*s006)*1e-9, 3) AS b_iitax,\n'
+    '  ROUND(SUM(r.iitax*s006)*1e-9, 3) AS r_iitax\n'
+    'FROM base JOIN baseline AS b USING(RECID) JOIN reform AS r USING(RECID)\n'
+    'WHERE MARS == 2;\n'
+    '\n'
+    '-- Documentation on the sqlite3 CLI program is available at\n'
+    '-- https://sqlite.org/cli.html\n'
+)
 
 
-def _write_expected_test_output():
+def _write_test_files():
     """
     Private function that writes tc --test input and expected output files.
     """
-    input_data = (
-        'RECID,MARS,XTOT,EIC,e00200,e00200p,e00200s,p23250,e18400,e19800\n'
-        '1,       2,   3,  1, 40000,  40000,      0,     0,  3000,  4000\n'
-        '2,       2,   3,  1,200000, 200000,      0,     0, 15000, 20000\n'
-    )
     with open(TEST_INPUT_FILENAME, 'w', encoding='utf-8') as ifile:
-        ifile.write(input_data)
-    expected_output_data = (
-        'RECID,YEAR,WEIGHT,INCTAX,LSTAX,PAYTAX\n'
-        '1,2018,0.00,131.88,0.00,6120.00\n'
-        '2,2018,0.00,28879.00,0.00,21721.60\n'
-    )
-    with open(EXPECTED_TEST_OUTPUT_FILENAME, 'w', encoding='utf-8') as ofile:
-        ofile.write(expected_output_data)
+        ifile.write(TEST_INPUT_DATA)
+    with open(EXPECTED_TEST_FILENAME, 'w', encoding='utf-8') as ofile:
+        ofile.write(EXPECTED_TEST_OUTPUT)
+    with open(TEST_TABULATE_FILENAME, 'w', encoding='utf-8') as tfile:
+        tfile.write(TEST_TABULATE_SQLCODE)
 
 
 def _compare_test_output_files():
     """
-    Private function that compares expected and actual tc --test output files;
+    Private function that compares expected and actual tc --test results;
     returns 0 if pass test, otherwise returns 1.
     """
-    with open(EXPECTED_TEST_OUTPUT_FILENAME, 'r', encoding='utf-8') as efile:
+    # use TEST_SQLITE_QUERY to extract results from TEST_DUMPDB_FILENAME
+    with sqlite3.connect(TEST_DUMPDB_FILENAME) as connection:
+        cursor = connection.cursor()
+        cursor.execute(TEST_SQLITE_QUERY)
+        results = cursor.fetchall()
+        with open(ACTUAL_TEST_FILENAME, 'w', encoding='utf-8') as afile:
+            afile.write('id|itax\n')
+            for row in results:
+                afile.write(f'{row[0]}|{row[1]:.2f}\n')
+    # compare results in ACTUAL_TEST_FILENAME and in EXPECTED_TEST_FILENAME
+    with open(EXPECTED_TEST_FILENAME, 'r', encoding='utf-8') as efile:
         explines = efile.readlines()
-    with open(ACTUAL_TEST_OUTPUT_FILENAME, 'r', encoding='utf-8') as afile:
+    with open(ACTUAL_TEST_FILENAME, 'r', encoding='utf-8') as afile:
         actlines = afile.readlines()
     if ''.join(explines) == ''.join(actlines):
         sys.stdout.write('PASSED TEST\n')
@@ -266,8 +399,8 @@ def _compare_test_output_files():
         retcode = 1
         sys.stdout.write('FAILED TEST\n')
         diff = difflib.unified_diff(explines, actlines,
-                                    fromfile=EXPECTED_TEST_OUTPUT_FILENAME,
-                                    tofile=ACTUAL_TEST_OUTPUT_FILENAME, n=0)
+                                    fromfile=EXPECTED_TEST_FILENAME,
+                                    tofile=ACTUAL_TEST_FILENAME, n=0)
         sys.stdout.writelines(diff)
     return retcode
 

taxcalc/data.py

@@ -147,8 +147,8 @@ class Data():
 
     def increment_year(self):
         """
-        Add one to current year; and also does
-        extrapolation & reweighting for new current year if aged_data is True.
+        Add one to current year; and also does extrapolation & reweighting
+        of data for the new current year if self._aging_data is True.
         """
         # move to next year
         self.__current_year += 1

taxcalc/parameters.py

@@ -706,11 +706,6 @@ class Parameters(pt.Parameters):
         """Propery docstring"""
         return self.end_year - self.start_year + 1
 
-    @property
-    def parameter_warnings(self):
-        """Propery docstring"""
-        return self.errors or {}
-
     @property
     def parameter_errors(self):
         """Propery docstring"""

taxcalc/policy.py

@@ -62,15 +62,6 @@ class Policy(Parameters):
         'DependentCredit_before_CTC': 'is a removed parameter name',
         'FilerCredit_c': 'is a removed parameter name',
         'ALD_InvInc_ec_base_RyanBrady': 'is a removed parameter name',
-        # following parameter renamed in PR 2292 merged on 2019-04-15
-        "cpi_offset": (
-            "was renamed parameter_indexing_CPI_offset. "
-            "See documentation for change in usage."
-        ),
-        "CPI_offset": (
-            "was renamed parameter_indexing_CPI_offset. "
-            "See documentation for change in usage."
-        ),
         # following parameters renamed in PR 2345 merged on 2019-06-24
         'PT_excl_rt':
         'was renamed PT_qbid_rt in release 2.4.0',
@@ -170,9 +161,9 @@ class Policy(Parameters):
             vo["value"] for
             vo in self._data["parameter_indexing_CPI_offset"]["value"]
         ]
-        # policy_current_law.json should not specify any non-zero values
-        # for the parameter_indexing_CPI_offset parameter, so check this
-        assert any(cpi_vals) is False
+        # parameter_indexing_CPI_offset parameter is no longer used, so check:
+        assert any(cpi_vals) is False, \
+            'obsolete parameter_indexing_CPI_offset values must all be zero'
         syr = max(self.start_year, self._gfactors.first_year)
         self._inflation_rates = self._gfactors.price_inflation_rates(
             syr, self.end_year