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

taxcalc/parameters.py

@@ -1,13 +1,14 @@
+"""
+Tax-Calculator abstract base parameter class based on paramtools package.
+"""
+
 import os
 import copy
 from collections import defaultdict
 from typing import Union, Mapping, Any, List
-
+import numpy as np
 import marshmallow as ma
 import paramtools as pt
-import numpy as np
-
-from taxcalc.growfactors import GrowFactors
 
 
 class CompatibleDataSchema(ma.Schema):
@@ -64,8 +65,8 @@ class Parameters(pt.Parameters):
     Check out the ParamTools
     `documentation <https://paramtools.dev/api/reference.html>`_
     for more information on these inherited methods.
-
     """
+    # pylint: disable=too-many-instance-attributes
     defaults = None
     array_first = True
     label_to_extend = "year"
@@ -83,6 +84,8 @@ class Parameters(pt.Parameters):
 
     def __init__(self, start_year=None, num_years=None, last_known_year=None,
                  removed=None, redefined=None, wage_indexed=None, **kwargs):
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
+
         # In case we need to wait for this to be called from the
         # initialize method for legacy reasons.
         if not start_year or not num_years:
@@ -121,8 +124,12 @@ class Parameters(pt.Parameters):
         label["validators"]["range"]["max"] = last_budget_year
         super().__init__(**kwargs)
 
-    def adjust(
-        self, params_or_path, print_warnings=True, raise_errors=True, **kwargs
+    def adjust(  # pylint: disable=arguments-differ
+            # pylint warning W0221 is:
+            #   Number of parameters was 6 in 'Parameters.adjust' and
+            #   is now 5 in overriding 'Parameters.adjust' method
+            self, params_or_path,
+            print_warnings=True, raise_errors=True, **kwargs
     ):
         """
         Update parameter values using a ParamTools styled adjustment.
@@ -136,8 +143,10 @@ class Parameters(pt.Parameters):
 
                 {
                     "standard_deduction": [
-                        {"year": 2024, "marital_status": "single", "value": 10000.0},
-                        {"year": 2024, "marital_status": "joint", "value": 10000.0}
+                        {"year": 2024, "marital_status": "single",
+                         "value": 10000.0},
+                        {"year": 2024, "marital_status": "joint",
+                         "value": 10000.0}
                     ],
                     "ss_rate": [{"year": 2024, "value": 0.2}]}
                 }
@@ -154,7 +163,7 @@ class Parameters(pt.Parameters):
         adjustment : Dict
             Parsed paremeter dictionary
 
-        """  # noqa
+        """
         if print_warnings:
             _data = copy.deepcopy(self._data)
             kwargs["ignore_warnings"] = False
@@ -177,13 +186,15 @@ class Parameters(pt.Parameters):
         except pt.ValidationError as ve:
             if self.errors and raise_errors:
                 raise ve
-            elif self.errors and not raise_errors:
+            if self.errors and not raise_errors:
                 return {}
             if print_warnings:
                 print("WARNING:")
                 print(self.warnings)
             kwargs["ignore_warnings"] = True
+            # pylint: disable=possibly-used-before-assignment
             self._data = _data
+            # pylint: enable=possibly-used-before-assignment
             _warnings = copy.deepcopy(self._warnings)
             self._warnings = {}
             self._errors = {}
@@ -242,6 +253,8 @@ class Parameters(pt.Parameters):
           wiped out after the year in which the value is adjusted for the
           same hard-coding reason.
         """
+        # pylint: disable=too-many-statements,too-many-locals,too-many-branches
+
         # Temporarily turn off extra ops during the intermediary adjustments
         # so that expensive and unnecessary operations are not run.
         label_to_extend = self.label_to_extend
@@ -310,7 +323,7 @@ class Parameters(pt.Parameters):
             self.delete(to_delete, **kwargs)
 
             # 1.b For all others, these are years after last_known_year.
-            last_known_year = max(cpi_min_year["year"], self._last_known_year)
+            # last_known_year=max(cpi_min_year["year"],self._last_known_year)
             # calculate 2026 value, using new inflation rates, for parameters
             # that revert to their pre-TCJA values.
             long_params = ['II_brk7', 'II_brk6', 'II_brk5', 'II_brk4',
@@ -362,7 +375,15 @@ class Parameters(pt.Parameters):
                 ):
                     continue
                 if self._data[param].get("indexed", False):
-                    to_delete[param] = self.sel[param]["_auto"] == True  # noqa
+                    # pylint: disable=singleton-comparison
+                    to_delete[param] = self.sel[param]["_auto"] == True
+                    # pylint warning message:
+                    #   Comparison 'self.sel[param]['_auto'] == True' should
+                    #   be 'self.sel[param]['_auto'] is True' if checking for
+                    #   the singleton value True, or
+                    #   'bool(self.sel[param]['_auto'])' if testing for
+                    #   truthiness
+                    # pylint: enable=singleton-comparison
                     needs_reset.append(param)
 
             self.delete(to_delete, **kwargs)
@@ -405,13 +426,14 @@ class Parameters(pt.Parameters):
                         min_index_change_year, strict=False
                     )
 
-                    if len(list(vos)):
+                    if list(vos):
                         min_adj_year = min(vos, key=lambda vo: vo["year"])[
                             "year"
                         ]
                         self.delete(
                             {
-                                base_param: self.sel[base_param]["year"] > min_adj_year  # noqa
+                                base_param:
+                                self.sel[base_param]["year"] > min_adj_year
                             }
                         )
                         super().adjust({base_param: vos}, **kwargs)
@@ -482,40 +504,45 @@ class Parameters(pt.Parameters):
         )
         return adj
 
-    def get_index_rate(self, param, label_to_extend_val):
+    def get_index_rate(self, param, lte_val):
         """
         Initalize indexing data and return the indexing rate value
-        depending on the parameter name and label_to_extend_val, the value of
-        label_to_extend.
+        depending on the parameter name and lte_val (that is, the
+        label_to_extend_val), the value of label_to_extend.
         Returns: rate to use for indexing.
         """
         if not self._inflation_rates or not self._wage_growth_rates:
             self.set_rates()
         if param in self._wage_indexed:
-            return self.wage_growth_rates(year=label_to_extend_val)
-        else:
-            return self.inflation_rates(year=label_to_extend_val)
+            return self.wage_growth_rates(year=lte_val)
+        return self.inflation_rates(year=lte_val)
 
     def set_rates(self):
         """
-        This method is implemented by classes inheriting
-        Parameters.
+        This method is implemented by classes inheriting Parameters.
         """
         raise NotImplementedError()
 
     def wage_growth_rates(self, year=None):
+        """
+        Return wage growth rates used in parameter indexing.
+        """
         if year is not None:
             syr = max(self.start_year, self._gfactors.first_year)
             return self._wage_growth_rates[year - syr]
         return self._wage_growth_rates or []
 
     def inflation_rates(self, year=None):
+        """
+        Return price inflation rates used in parameter indexing.
+        """
         if year is not None:
             syr = max(self.start_year, self._gfactors.first_year)
             return self._inflation_rates[year - syr]
         return self._inflation_rates or []
 
-    # alias methods below
+    # alias methods below:
+
     def initialize(self, start_year, num_years, last_known_year=None,
                    removed=None, redefined=None, wage_indexed=None,
                    **kwargs):
@@ -523,13 +550,15 @@ class Parameters(pt.Parameters):
         Legacy method for initializing a Parameters instance. Projects
         should use the __init__ method in the future.
         """
-        # case where project hasn't been initialized yet.
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
+        # Handle case where project hasn't been initialized yet
         if getattr(self, "_data", None) is None:
             return Parameters.__init__(
                 self, start_year, num_years, last_known_year=last_known_year,
                 removed=removed, redefined=redefined,
                 wage_indexed=wage_indexed, **kwargs
             )
+        return None  # pragma: no cover
 
     def _update(self, revision, print_warnings, raise_errors):
         """
@@ -553,13 +582,16 @@ class Parameters(pt.Parameters):
 
             {
                 "standard_deduction": [
-                    {"year": 2024, "marital_status": "single", "value": 10000.0},
-                    {"year": 2024, "marital_status": "joint", "value": 10000.0}
+                    {"year": 2024, "marital_status": "single",
+                     "value": 10000.0},
+                    {"year": 2024, "marital_status": "joint",
+                     "value": 10000.0}
                 ],
                 "ss_rate": [{"year": 2024, "value": 0.2}]}
             }
 
-        """  # noqa: E501
+        """
+        # pylint: disable=too-many-branches
         if not isinstance(revision, dict):
             raise pt.ValidationError(
                 {"errors": {"schema": "Revision must be a dictionary."}},
@@ -651,30 +683,37 @@ class Parameters(pt.Parameters):
         )
 
     def set_year(self, year):
+        """Specify parameter year"""
         self.set_state(year=year)
 
     @property
     def current_year(self):
+        """Propery docstring"""
         return self.label_grid["year"][0]
 
     @property
     def start_year(self):
+        """Propery docstring"""
         return self._stateless_label_grid["year"][0]
 
     @property
     def end_year(self):
+        """Propery docstring"""
         return self._stateless_label_grid["year"][-1]
 
     @property
     def num_years(self):
+        """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"""
         return self.errors or {}
 
     @staticmethod
@@ -698,14 +737,17 @@ class Parameters(pt.Parameters):
 
         Some examples of valid links are:
 
-        - HTTP: ``https://raw.githubusercontent.com/PSLmodels/Tax-Calculator/master/taxcalc/reforms/2017_law.json``
+        - HTTP: ``https://raw.githubusercontent.com/PSLmodels/Tax-Calculator/
+                  master/taxcalc/reforms/2017_law.json``
 
-        - Github API: ``github://PSLmodels:Tax-Calculator@master/taxcalc/reforms/2017_law.json``
+        - Github API: ``github://PSLmodels:Tax-Calculator@master/taxcalc/
+                        reforms/2017_law.json``
 
         Checkout the ParamTools
-        `docs <https://paramtools.dev/_modules/paramtools/parameters.html#Parameters.read_params>`_
+        `docs <https://paramtools.dev/_modules/paramtools/
+                       parameters.html#Parameters.read_params>`_
         for more information on valid file URLs.
-        """  # noqa
+        """
         # embedded function used only in _read_json_revision staticmethod
         def convert_year_to_int(syr_dict):
             """
@@ -713,10 +755,10 @@ class Parameters(pt.Parameters):
             keys, into a dictionary with the same structure but having integer
             years as secondary keys.
             """
-            iyr_dict = dict()
+            iyr_dict = {}
             for pkey, sdict in syr_dict.items():
                 assert isinstance(pkey, str)
-                iyr_dict[pkey] = dict()
+                iyr_dict[pkey] = {}
                 assert isinstance(sdict, dict)
                 for skey, val in sdict.items():
                     assert isinstance(skey, str)
@@ -726,7 +768,7 @@ class Parameters(pt.Parameters):
         # end of embedded function
         # process the main function arguments
         if obj is None:
-            return dict()
+            return {}
 
         full_dict = pt.read_json(obj)
 
@@ -743,6 +785,9 @@ class Parameters(pt.Parameters):
         return convert_year_to_int(single_dict)
 
     def metadata(self):
+        """
+        Return parameter specification.
+        """
         return self.specification(meta_data=True, use_state=False)
 
     @staticmethod
@@ -752,7 +797,7 @@ class Parameters(pt.Parameters):
         assumed to have a param:year:value format.
         """
         assert isinstance(revision, dict)
-        years = list()
+        years = []
         for _, paramdata in revision.items():
             assert isinstance(paramdata, dict)
             for year, _ in paramdata.items():
@@ -774,8 +819,7 @@ class Parameters(pt.Parameters):
             return self.to_array(
                 attr[1:], year=list(range(self.start_year, self.end_year + 1))
             )
-        else:
-            raise AttributeError(f"{attr} is not defined.")
+        raise AttributeError(f"{attr} is not defined.")
 
 
 TaxcalcReform = Union[str, Mapping[int, Any]]
@@ -815,7 +859,6 @@ def is_paramtools_format(params: Union[TaxcalcReform, ParamToolsAdjustment]):
     for data in params.values():
         if isinstance(data, dict):
             return False  # taxcalc reform
-        else:
-            # Not doing a specific check to see if the value is a list
-            # since it could be a list or just a scalar value.
-            return True
+        # Not doing a specific check to see if the value is a list
+        # since it could be a list or just a scalar value.
+        return True

taxcalc/policy.py

@@ -158,7 +158,7 @@ class Policy(Parameters):
             Policy.DEFAULTS_FILE_PATH,
             Policy.DEFAULTS_FILE_NAME
         )
-        with open(path, 'r',  encoding='utf-8') as f:
+        with open(path, 'r', encoding='utf-8') as f:
             defaults = json.loads(f.read())  # pylint: disable=protected-access
         return [k for k in defaults if k != "schema"]
 

taxcalc/records.py

@@ -136,6 +136,7 @@ class Records(Data):
                  adjust_ratios=PUF_RATIOS_FILENAME,
                  exact_calculations=False,
                  weights_scale=0.01):
+        # pylint: disable=too-many-positional-arguments
         # pylint: disable=no-member,too-many-branches
         if isinstance(weights, str):
             weights = os.path.join(Records.CODE_PATH, weights)

taxcalc/records_variables.json

@@ -842,6 +842,12 @@
       "form": {"2013-2013": "1040 line 46 minus 1040 line 55",
                "2014-2016": "1040 line 47 minus 1040 line 56"}
     },
+    "c32800": {
+      "type": "float",
+      "desc": "Child and dependent care expenses capped by policy (not by earnings)",
+      "form": {"2013-2013": "1040 line 48",
+               "2014-2016": "1040 line 49"}
+    },
     "c07180": {
       "type": "float",
       "desc": "Nonrefundable credit for child and dependent care expenses from Form 2441",

taxcalc/taxcalcio.py

@@ -66,8 +66,8 @@ class TaxCalcIO():
 
     def __init__(self, input_data, tax_year, baseline, reform, assump,
                  outdir=None):
-        # pylint: disable=too-many-arguments,too-many-locals
-        # pylint: disable=too-many-branches,too-many-statements
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
+        # pylint: disable=too-many-branches,too-many-statements,too-many-locals
         self.gf_reform = None
         self.errmsg = ''
         # check name and existence of INPUT file
@@ -82,17 +82,17 @@ class TaxCalcIO():
             fname = os.path.basename(input_data)
             # check if fname ends with ".csv"
             if fname.endswith('.csv'):
-                inp = '{}-{}'.format(fname[:-4], str(tax_year)[2:])
+                inp = f'{fname[:-4]}-{str(tax_year)[2:]}'
             else:
                 msg = 'INPUT file name does not end in .csv'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
             # check existence of INPUT file
             self.puf_input_data = input_data.endswith('puf.csv')
             self.cps_input_data = input_data.endswith('cps.csv')
             self.tmd_input_data = input_data.endswith('tmd.csv')
             if not self.cps_input_data and not os.path.isfile(input_data):
                 msg = 'INPUT file could not be found'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
             # if tmd_input_data is True, construct weights and gfactor paths
             if self.tmd_input_data:  # pragma: no cover
                 tmd_dir = os.path.dirname(input_data)
@@ -106,15 +106,15 @@ class TaxCalcIO():
                 self.tmd_gfactor = os.path.join(tmd_dir, 'tmd_growfactors.csv')
                 if not os.path.isfile(self.tmd_weights):
                     msg = f'weights file {self.tmd_weights} could not be found'
-                    self.errmsg += 'ERROR: {}\n'.format(msg)
+                    self.errmsg += f'ERROR: {msg}\n'
                 if not os.path.isfile(self.tmd_gfactor):
                     msg = f'gfactor file {self.tmd_gfactor} could not be found'
-                    self.errmsg += 'ERROR: {}\n'.format(msg)
+                    self.errmsg += f'ERROR: {msg}\n'
         elif isinstance(input_data, pd.DataFrame):
-            inp = 'df-{}'.format(str(tax_year)[2:])
+            inp = f'df-{str(tax_year)[2:]}'
         else:
             msg = 'INPUT is neither string nor Pandas DataFrame'
-            self.errmsg += 'ERROR: {}\n'.format(msg)
+            self.errmsg += f'ERROR: {msg}\n'
         # check name and existence of BASELINE file
         bas = '-x'
         if baseline is None:
@@ -124,17 +124,17 @@ class TaxCalcIO():
             fname = os.path.basename(baseline)
             # check if fname ends with ".json"
             if fname.endswith('.json'):
-                bas = '-{}'.format(fname[:-5])
+                bas = f'-{fname[:-5]}'
             else:
                 msg = 'BASELINE file name does not end in .json'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
             # check existence of BASELINE file
             if not os.path.isfile(baseline):
                 msg = 'BASELINE file could not be found'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
         else:
             msg = 'TaxCalcIO.ctor: baseline is neither None nor str'
-            self.errmsg += 'ERROR: {}\n'.format(msg)
+            self.errmsg += f'ERROR: {msg}\n'
         # check name(s) and existence of REFORM file(s)
         ref = '-x'
         if reform is None:
@@ -150,12 +150,12 @@ class TaxCalcIO():
                 fname = os.path.basename(rfm)
                 # check if fname ends with ".json"
                 if not fname.endswith('.json'):
-                    msg = '{} does not end in .json'.format(fname)
-                    self.errmsg += 'ERROR: REFORM file name {}\n'.format(msg)
+                    msg = f'{fname} does not end in .json'
+                    self.errmsg += f'ERROR: REFORM file name {msg}\n'
                 # check existence of REFORM file
                 if not os.path.isfile(rfm):
-                    msg = '{} could not be found'.format(rfm)
-                    self.errmsg += 'ERROR: REFORM file {}\n'.format(msg)
+                    msg = f'{rfm} could not be found'
+                    self.errmsg += f'ERROR: REFORM file {msg}\n'
                 # add fname to list of refnames used in output file names
                 refnames.append(fname)
             # create (possibly compound) reform name for output file names
@@ -165,10 +165,10 @@ class TaxCalcIO():
                 num_refnames += 1
                 if num_refnames > 1:
                     ref += '+'
-                ref += '{}'.format(refname[:-5])
+                ref += f'{refname[:-5]}'
         else:
             msg = 'TaxCalcIO.ctor: reform is neither None nor str'
-            self.errmsg += 'ERROR: {}\n'.format(msg)
+            self.errmsg += f'ERROR: {msg}\n'
         # check name and existence of ASSUMP file
         asm = '-x'
         if assump is None:
@@ -178,17 +178,17 @@ class TaxCalcIO():
             fname = os.path.basename(assump)
             # check if fname ends with ".json"
             if fname.endswith('.json'):
-                asm = '-{}'.format(fname[:-5])
+                asm = f'-{fname[:-5]}'
             else:
                 msg = 'ASSUMP file name does not end in .json'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
             # check existence of ASSUMP file
             if not os.path.isfile(assump):
                 msg = 'ASSUMP file could not be found'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
         else:
             msg = 'TaxCalcIO.ctor: assump is neither None nor str'
-            self.errmsg += 'ERROR: {}\n'.format(msg)
+            self.errmsg += f'ERROR: {msg}\n'
         # check name and existence of OUTDIR
         if outdir is None:
             valid_outdir = True
@@ -199,13 +199,13 @@ class TaxCalcIO():
             else:
                 valid_outdir = False
                 msg = 'OUTDIR could not be found'
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                self.errmsg += f'ERROR: {msg}\n'
         else:
             valid_outdir = False
             msg = 'TaxCalcIO.ctor: outdir is neither None nor str'
-            self.errmsg += 'ERROR: {}\n'.format(msg)
+            self.errmsg += f'ERROR: {msg}\n'
         # create OUTPUT file name and delete any existing output files
-        output_filename = '{}{}{}{}.csv'.format(inp, bas, ref, asm)
+        output_filename = f'{inp}{bas}{ref}{asm}.csv'
         if outdir is None:
             self._output_filename = output_filename
             delete_old_files = True
@@ -246,8 +246,8 @@ class TaxCalcIO():
             specifies whether or not exact tax calculations are done without
             any smoothing of "stair-step" provisions in the tax law.
         """
-        # pylint: disable=too-many-arguments,too-many-locals
-        # pylint: disable=too-many-statements,too-many-branches
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
+        # pylint: disable=too-many-statements,too-many-branches,too-many-locals
         self.errmsg = ''
         # instantiate base and reform GrowFactors objects
         if self.tmd_input_data:
@@ -300,7 +300,7 @@ class TaxCalcIO():
         try:
             gdiff_baseline.update_growdiff(paramdict['growdiff_baseline'])
         except paramtools.ValidationError as valerr_msg:
-            self.errmsg += valerr_msg.__str__()
+            self.errmsg += str(valerr_msg)
         # apply gdiff_baseline to gfactor_base
         gdiff_baseline.apply_to(gfactors_base)
         # specify gdiff_response object
@@ -308,7 +308,7 @@ class TaxCalcIO():
         try:
             gdiff_response.update_growdiff(paramdict['growdiff_response'])
         except paramtools.ValidationError as valerr_msg:
-            self.errmsg += valerr_msg.__str__()
+            self.errmsg += str(valerr_msg)
         # apply gdiff_baseline and gdiff_response to gfactor_ref
         gdiff_baseline.apply_to(gfactors_ref)
         gdiff_response.apply_to(gfactors_ref)
@@ -323,7 +323,7 @@ class TaxCalcIO():
             for _, errors in base.parameter_errors.items():
                 self.errmsg += "\n".join(errors)
         except paramtools.ValidationError as valerr_msg:
-            self.errmsg += valerr_msg.__str__()
+            self.errmsg += str(valerr_msg)
         # ... the reform Policy object
         if self.specified_reform:
             pol = Policy(gfactors=gfactors_ref, last_budget_year=last_b_year)
@@ -337,7 +337,7 @@ class TaxCalcIO():
                     for _, errors in pol.parameter_errors.items():
                         self.errmsg += "\n".join(errors)
                 except paramtools.ValidationError as valerr_msg:
-                    self.errmsg += valerr_msg.__str__()
+                    self.errmsg += str(valerr_msg)
         else:
             pol = Policy(gfactors=gfactors_base, last_budget_year=last_b_year)
         # create Consumption object
@@ -345,7 +345,7 @@ class TaxCalcIO():
         try:
             con.update_consumption(paramdict['consumption'])
         except paramtools.ValidationError as valerr_msg:
-            self.errmsg += valerr_msg.__str__()
+            self.errmsg += str(valerr_msg)
         # any errors imply cannot proceed with calculations
         if self.errmsg:
             return
@@ -431,9 +431,8 @@ class TaxCalcIO():
         valid_set = recs_vinfo.USABLE_READ_VARS | recs_vinfo.CALCULATED_VARS
         for var in dump_vars_list:
             if var not in valid_set:
-                msg = 'invalid variable name in tcdumpvars file: {}'
-                msg = msg.format(var)
-                self.errmsg += 'ERROR: {}\n'.format(msg)
+                msg = f'invalid variable name in tcdumpvars file: {var}'
+                self.errmsg += f'ERROR: {msg}\n'
         # add essential variables even if not on custom list
         if 'RECID' not in dump_vars_list:
             dump_vars_list.append('RECID')
@@ -494,7 +493,8 @@ class TaxCalcIO():
         -------
         Nothing
         """
-        # pylint: disable=too-many-arguments,too-many-branches,too-many-locals
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
+        # pylint: disable=too-many-branches,too-many-locals
         if self.puf_input_data and self.calc.reform_warnings:
             warn = 'PARAMETER VALUE WARNING(S):  {}\n{}{}'  # pragma: no cover
             print(  # pragma: no cover
@@ -599,6 +599,7 @@ class TaxCalcIO():
         """
         Write dump output to SQLite3 database table dump.
         """
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
         db_fname = self._output_filename.replace('.csv', '.db')
         dbcon = sqlite3.connect(db_fname)
         # write baseline table
@@ -685,8 +686,9 @@ class TaxCalcIO():
             weighted_sum, 'combined', include_groups=False
         ).values[:, 1]
         # write decile table to text file
-        row = 'Weighted Tax {} by Baseline Expanded-Income Decile\n'
-        tfile.write(row.format(tkind))
+        row = f'Weighted Tax {tkind} by Baseline Expanded-Income Decile\n'
+        tfile.write(row)
+        # pylint: disable=consider-using-f-string
         rowfmt = '{}{}{}{}{}{}\n'
         row = rowfmt.format('    Returns',
                             '    ExpInc',
@@ -704,7 +706,7 @@ class TaxCalcIO():
         tfile.write(row)
         rowfmt = '{:9.2f}{:10.1f}{:10.1f}{:10.1f}{:10.1f}{:10.1f}\n'
         for decile in range(0, 10):
-            row = '{:2d}'.format(decile)
+            row = f'{decile:2d}'
             row += rowfmt.format(rtns_series[decile] * 1e-6,
                                  xinc_series[decile] * 1e-9,
                                  itax_series[decile] * 1e-9,
@@ -720,6 +722,7 @@ class TaxCalcIO():
                              htax_series.sum() * 1e-9,
                              ctax_series.sum() * 1e-9)
         tfile.write(row)
+        # pylint: enable=consider-using-f-string
         del gdfx
         del rtns_series
         del xinc_series
@@ -776,10 +779,12 @@ class TaxCalcIO():
         """
         Write HTML graph file with title but no graph for specified reason.
         """
-        txt = ('<html>\n'
-               '<head><title>{}</title></head>\n'
-               '<body><center<h1>{}</h1></center></body>\n'
-               '</html>\n').format(title, reason)
+        txt = (
+            '<html>\n'
+            f'<head><title>{title}</title></head>\n'
+            f'<body><center<h1>{reason}</h1></center></body>\n'
+            '</html>\n'
+        )
         with open(fname, 'w', encoding='utf-8') as gfile:
             gfile.write(txt)