taxcalc 4.3.5__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:
@@ -98,19 +101,16 @@ class Parameters(pt.Parameters):
                 self.DEFAULTS_FILE_PATH,
                 self.DEFAULTS_FILE_NAME
             )
-
+        last_budget_year = start_year + num_years - 1
         if last_known_year is None:
             self._last_known_year = start_year
         else:
             assert last_known_year >= start_year
-            assert last_known_year <= self.LAST_BUDGET_YEAR
+            assert last_known_year <= last_budget_year
             self._last_known_year = last_known_year
-
         self._removed_params = removed or self.REMOVED_PARAMS
         self._redefined_params = redefined or self.REDEFINED_PARAMS
-
         self._wage_indexed = wage_indexed or self.WAGE_INDEXED_PARAMS
-
         if (
             (start_year or self.JSON_START_YEAR) and
             "initial_state" not in kwargs
@@ -118,10 +118,18 @@ class Parameters(pt.Parameters):
             kwargs["initial_state"] = {
                 "year": start_year or self.JSON_START_YEAR
             }
+        # update defaults to correspond to user-defined parameter years
+        self.defaults = super().get_defaults()
+        label = self.defaults["schema"]["labels"]["year"]
+        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.
@@ -135,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}]}
                 }
@@ -153,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
@@ -176,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 = {}
@@ -241,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
@@ -309,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',
@@ -361,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)
@@ -404,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)
@@ -481,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):
@@ -522,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):
         """
@@ -552,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."}},
@@ -650,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
@@ -697,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):
             """
@@ -712,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)
@@ -725,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)
 
@@ -742,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
@@ -751,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():
@@ -773,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} not definied.")
+        raise AttributeError(f"{attr} is not defined.")
 
 
 TaxcalcReform = Union[str, Mapping[int, Any]]
@@ -814,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

@@ -24,6 +24,9 @@ class Policy(Parameters):
     gfactors: GrowFactors class instance
         containing price inflation rates and wage growth rates
 
+    last_budget_year: integer
+        user-defined last parameter extrapolation year
+
     Raises
     ------
     ValueError:
@@ -39,9 +42,16 @@ class Policy(Parameters):
     JSON_START_YEAR = 2013  # remains the same unless earlier data added
     LAST_KNOWN_YEAR = 2025  # last year for which indexed param vals are known
     # should increase LAST_KNOWN_YEAR by one every calendar year
-    LAST_BUDGET_YEAR = 2034  # last extrapolation year
+    LAST_BUDGET_YEAR = 2034  # default value of last extrapolation year
     # should increase LAST_BUDGET_YEAR by one every calendar year
-    DEFAULT_NUM_YEARS = LAST_BUDGET_YEAR - JSON_START_YEAR + 1
+
+    @staticmethod
+    def number_of_years(last_budget_year=LAST_BUDGET_YEAR):
+        """
+        Static method returns number of policy parameters years given
+        user-defined last_budget_year.
+        """
+        return last_budget_year - Policy.JSON_START_YEAR + 1
 
     # NOTE: the following three data structures use internal parameter names:
     # (1) specify which Policy parameters have been removed or renamed
@@ -80,7 +90,10 @@ class Policy(Parameters):
     # (3) specify which Policy parameters are wage (rather than price) indexed
     WAGE_INDEXED_PARAMS = ['SS_Earnings_c', 'SS_Earnings_thd']
 
-    def __init__(self, gfactors=None, **kwargs):
+    def __init__(self,
+                 gfactors=None,
+                 last_budget_year=LAST_BUDGET_YEAR,
+                 **kwargs):
         # put JSON contents of DEFAULTS_FILE_NAME into self._vals dictionary
         super().__init__()
         # handle gfactors argument
@@ -92,7 +105,7 @@ class Policy(Parameters):
             raise ValueError('gfactors is not None or a GrowFactors instance')
         # read default parameters and initialize
         syr = Policy.JSON_START_YEAR
-        nyrs = Policy.DEFAULT_NUM_YEARS
+        nyrs = Policy.number_of_years(last_budget_year)
         self._inflation_rates = None
         self._wage_growth_rates = None
         self.initialize(syr, nyrs, Policy.LAST_KNOWN_YEAR,
@@ -101,7 +114,10 @@ class Policy(Parameters):
                         Policy.WAGE_INDEXED_PARAMS, **kwargs)
 
     @staticmethod
-    def tmd_constructor(growfactors: Path | GrowFactors):  # pragma: no cover
+    def tmd_constructor(
+            growfactors: Path | GrowFactors,
+            last_budget_year=LAST_BUDGET_YEAR,
+    ):  # pragma: no cover
         """
         Static method returns a Policy object instantiated with TMD
         input data.  This convenience method works in a analogous way
@@ -112,7 +128,7 @@ class Policy(Parameters):
             growfactors = GrowFactors(growfactors_filename=str(growfactors))
         else:
             assert isinstance(growfactors, GrowFactors)
-        return Policy(gfactors=growfactors)
+        return Policy(gfactors=growfactors, last_budget_year=last_budget_year)
 
     @staticmethod
     def read_json_reform(obj):
@@ -142,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/reforms/ext.json

@@ -1,5 +1,5 @@
 // REFORM TO EXTEND TEMPORARY TCJA PROVISIONS BEYOND 2025
-// USING TAX-CALCULATOR 4.3.5
+// USING TAX-CALCULATOR 4.4.0
 // WITH 2025-to-2026 INDEXING FACTOR = 1.024900
 //  AND 2028-to-2029 INDEXING FACTOR = 1.021800
 {