OpenFisca-Core-test 46.0.0__py3-none-any.whl

openfisca_core/taxscales/abstract_tax_scale.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import typing
+import warnings
+
+from .tax_scale_like import TaxScaleLike
+
+if typing.TYPE_CHECKING:
+    import numpy
+
+    NumericalArray = numpy.int32 | numpy.float32
+
+
+class AbstractTaxScale(TaxScaleLike):
+    """Base class for various types of tax scales: amount-based tax scales,
+    rate-based tax scales...
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        option: typing.Any = None,
+        unit: numpy.int16 = None,
+    ) -> None:
+        message = [
+            "The 'AbstractTaxScale' class has been deprecated since",
+            "version 34.7.0, and will be removed in the future.",
+        ]
+
+        warnings.warn(" ".join(message), DeprecationWarning, stacklevel=2)
+        super().__init__(name, option, unit)
+
+    def __repr__(self) -> typing.NoReturn:
+        msg = f"Method '__repr__' is not implemented for {self.__class__.__name__}"
+        raise NotImplementedError(
+            msg,
+        )
+
+    def calc(
+        self,
+        tax_base: NumericalArray,
+        right: bool,
+    ) -> typing.NoReturn:
+        msg = f"Method 'calc' is not implemented for {self.__class__.__name__}"
+        raise NotImplementedError(
+            msg,
+        )
+
+    def to_dict(self) -> typing.NoReturn:
+        msg = f"Method 'to_dict' is not implemented for {self.__class__.__name__}"
+        raise NotImplementedError(
+            msg,
+        )

openfisca_core/taxscales/amount_tax_scale_like.py

@@ -0,0 +1,55 @@
+import abc
+import bisect
+import os
+import typing
+
+from openfisca_core import tools
+
+from .tax_scale_like import TaxScaleLike
+
+
+class AmountTaxScaleLike(TaxScaleLike, abc.ABC):
+    """Base class for various types of amount-based tax scales: single amount,
+    marginal amount...
+    """
+
+    amounts: list
+
+    def __init__(
+        self,
+        name: str | None = None,
+        option: typing.Any = None,
+        unit: typing.Any = None,
+    ) -> None:
+        super().__init__(name, option, unit)
+        self.amounts = []
+
+    def __repr__(self) -> str:
+        return tools.indent(
+            os.linesep.join(
+                [
+                    f"- threshold: {threshold}{os.linesep}  amount: {amount}"
+                    for (threshold, amount) in zip(self.thresholds, self.amounts)
+                ],
+            ),
+        )
+
+    def add_bracket(
+        self,
+        threshold: int,
+        amount: float,
+    ) -> None:
+        if threshold in self.thresholds:
+            i = self.thresholds.index(threshold)
+            self.amounts[i] += amount
+
+        else:
+            i = bisect.bisect_left(self.thresholds, threshold)
+            self.thresholds.insert(i, threshold)
+            self.amounts.insert(i, amount)
+
+    def to_dict(self) -> dict:
+        return {
+            str(threshold): self.amounts[index]
+            for index, threshold in enumerate(self.thresholds)
+        }

openfisca_core/taxscales/helpers.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+import typing
+
+from openfisca_core import taxscales
+
+log = logging.getLogger(__name__)
+
+if typing.TYPE_CHECKING:
+    from openfisca_core.parameters import ParameterNodeAtInstant
+
+    TaxScales = taxscales.MarginalRateTaxScale | None
+
+
+def combine_tax_scales(
+    node: ParameterNodeAtInstant,
+    combined_tax_scales: TaxScales = None,
+) -> TaxScales:
+    """Combine all the MarginalRateTaxScales in the node into a single
+    MarginalRateTaxScale.
+    """
+    name = next(iter(node or []), None)
+
+    if name is None:
+        return combined_tax_scales
+
+    if combined_tax_scales is None:
+        combined_tax_scales = taxscales.MarginalRateTaxScale(name=name)
+        combined_tax_scales.add_bracket(0, 0)
+
+    for child_name in node:
+        child = node[child_name]
+
+        if isinstance(child, taxscales.MarginalRateTaxScale):
+            combined_tax_scales.add_tax_scale(child)
+
+        else:
+            log.info(
+                f"Skipping {child_name} with value {child} "
+                "because it is not a marginal rate tax scale",
+            )
+
+    return combined_tax_scales

openfisca_core/taxscales/linear_average_rate_tax_scale.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import logging
+import typing
+
+import numpy
+
+from openfisca_core import taxscales
+
+from .rate_tax_scale_like import RateTaxScaleLike
+
+log = logging.getLogger(__name__)
+
+if typing.TYPE_CHECKING:
+    NumericalArray = numpy.int32 | numpy.float32
+
+
+class LinearAverageRateTaxScale(RateTaxScaleLike):
+    def calc(
+        self,
+        tax_base: NumericalArray,
+        right: bool = False,
+    ) -> numpy.float32:
+        if len(self.rates) == 1:
+            return tax_base * self.rates[0]
+
+        tiled_base = numpy.tile(tax_base, (len(self.thresholds) - 1, 1)).T
+        tiled_thresholds = numpy.tile(self.thresholds, (len(tax_base), 1))
+
+        bracket_dummy = (tiled_base >= tiled_thresholds[:, :-1]) * (
+            +tiled_base < tiled_thresholds[:, 1:]
+        )
+
+        rates_array = numpy.array(self.rates)
+        thresholds_array = numpy.array(self.thresholds)
+
+        rate_slope = (rates_array[1:] - rates_array[:-1]) / (
+            +thresholds_array[1:] - thresholds_array[:-1]
+        )
+
+        average_rate_slope = numpy.dot(bracket_dummy, rate_slope.T)
+
+        bracket_average_start_rate = numpy.dot(bracket_dummy, rates_array[:-1])
+        bracket_threshold = numpy.dot(bracket_dummy, thresholds_array[:-1])
+
+        log.info(f"bracket_average_start_rate :  {bracket_average_start_rate}")
+        log.info(f"average_rate_slope:  {average_rate_slope}")
+
+        return tax_base * (
+            +bracket_average_start_rate
+            + (tax_base - bracket_threshold) * average_rate_slope
+        )
+
+    def to_marginal(self) -> taxscales.MarginalRateTaxScale:
+        marginal_tax_scale = taxscales.MarginalRateTaxScale(
+            name=self.name,
+            option=self.option,
+            unit=self.unit,
+        )
+
+        previous_i = 0
+        previous_threshold = 0
+
+        for threshold, rate in zip(self.thresholds[1:], self.rates[1:]):
+            if threshold != float("Inf"):
+                i = rate * threshold
+                marginal_tax_scale.add_bracket(
+                    previous_threshold,
+                    (i - previous_i) / (threshold - previous_threshold),
+                )
+                previous_i = i
+                previous_threshold = threshold
+
+        marginal_tax_scale.add_bracket(previous_threshold, rate)
+
+        return marginal_tax_scale

openfisca_core/taxscales/marginal_amount_tax_scale.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing
+
+import numpy
+
+from .amount_tax_scale_like import AmountTaxScaleLike
+
+if typing.TYPE_CHECKING:
+    NumericalArray = numpy.int32 | numpy.float32
+
+
+class MarginalAmountTaxScale(AmountTaxScaleLike):
+    def calc(
+        self,
+        tax_base: NumericalArray,
+        right: bool = False,
+    ) -> numpy.float32:
+        """Matches the input amount to a set of brackets and returns the sum of
+        cell values from the lowest bracket to the one containing the input.
+        """
+        base1 = numpy.tile(tax_base, (len(self.thresholds), 1)).T
+
+        thresholds1 = numpy.tile(
+            numpy.hstack((self.thresholds, numpy.inf)),
+            (len(tax_base), 1),
+        )
+
+        a = numpy.maximum(
+            numpy.minimum(base1, thresholds1[:, 1:]) - thresholds1[:, :-1],
+            0,
+        )
+
+        return numpy.dot(self.amounts, a.T > 0)

openfisca_core/taxscales/marginal_rate_tax_scale.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import bisect
+import itertools
+import typing
+
+import numpy
+
+from openfisca_core import taxscales
+
+from .rate_tax_scale_like import RateTaxScaleLike
+
+if typing.TYPE_CHECKING:
+    NumericalArray = numpy.int32 | numpy.float32
+
+
+class MarginalRateTaxScale(RateTaxScaleLike):
+    def add_tax_scale(self, tax_scale: RateTaxScaleLike) -> None:
+        # So as not to have problems with empty scales
+        if len(tax_scale.thresholds) > 0:
+            for threshold_low, threshold_high, rate in zip(
+                tax_scale.thresholds[:-1],
+                tax_scale.thresholds[1:],
+                tax_scale.rates,
+            ):
+                self.combine_bracket(rate, threshold_low, threshold_high)
+
+            # To process the last threshold
+            self.combine_bracket(
+                tax_scale.rates[-1],
+                tax_scale.thresholds[-1],
+            )
+
+    def calc(
+        self,
+        tax_base: NumericalArray,
+        factor: float = 1.0,
+        round_base_decimals: int | None = None,
+    ) -> numpy.float32:
+        """Compute the tax amount for the given tax bases by applying a taxscale.
+
+        :param ndarray tax_base: Array of the tax bases.
+        :param float factor: Factor to apply to the thresholds of the taxscale.
+        :param int round_base_decimals: Decimals to keep when rounding
+                                        thresholds.
+
+        :returns: Float array with tax amount for the given tax bases.
+
+        For instance:
+
+        >>> tax_scale = MarginalRateTaxScale()
+        >>> tax_scale.add_bracket(0, 0)
+        >>> tax_scale.add_bracket(100, 0.1)
+        >>> tax_base = array([0, 150])
+        >>> tax_scale.calc(tax_base)
+        [0.0, 5.0]
+        """
+        base1 = numpy.tile(tax_base, (len(self.thresholds), 1)).T
+        factor = numpy.ones(len(tax_base)) * factor
+
+        # To avoid the creation of:
+        #
+        #   numpy.nan = 0 * numpy.inf
+        #
+        # We use:
+        #
+        #   numpy.finfo(float_).eps
+        thresholds1 = numpy.outer(
+            factor + numpy.finfo(numpy.float64).eps,
+            numpy.array([*self.thresholds, numpy.inf]),
+        )
+
+        if round_base_decimals is not None:
+            thresholds1 = numpy.round(thresholds1, round_base_decimals)
+
+        a = numpy.maximum(
+            numpy.minimum(base1, thresholds1[:, 1:]) - thresholds1[:, :-1],
+            0,
+        )
+
+        if round_base_decimals is None:
+            return numpy.dot(self.rates, a.T)
+
+        r = numpy.tile(self.rates, (len(tax_base), 1))
+        b = numpy.round(a, round_base_decimals)
+        return numpy.round(r * b, round_base_decimals).sum(axis=1)
+
+    def combine_bracket(
+        self,
+        rate: float,
+        threshold_low: int = 0,
+        threshold_high: int | bool = False,
+    ) -> None:
+        # Insert threshold_low and threshold_high without modifying rates
+        if threshold_low not in self.thresholds:
+            index = bisect.bisect_right(self.thresholds, threshold_low) - 1
+            self.add_bracket(threshold_low, self.rates[index])
+
+        if threshold_high and threshold_high not in self.thresholds:
+            index = bisect.bisect_right(self.thresholds, threshold_high) - 1
+            self.add_bracket(threshold_high, self.rates[index])
+
+        # Use add_bracket to add rates where they belongs
+        i = self.thresholds.index(threshold_low)
+
+        if threshold_high:
+            j = self.thresholds.index(threshold_high) - 1
+
+        else:
+            j = len(self.thresholds) - 1
+
+        while i <= j:
+            self.add_bracket(self.thresholds[i], rate)
+            i += 1
+
+    def marginal_rates(
+        self,
+        tax_base: NumericalArray,
+        factor: float = 1.0,
+        round_base_decimals: int | None = None,
+    ) -> numpy.float32:
+        """Compute the marginal tax rates relevant for the given tax bases.
+
+        :param ndarray tax_base: Array of the tax bases.
+        :param float factor: Factor to apply to the thresholds of a tax scale.
+        :param int round_base_decimals: Decimals to keep when rounding
+                                        thresholds.
+
+        :returns: Float array with relevant marginal tax rate for the given tax
+                  bases.
+
+        For instance:
+
+        >>> tax_scale = MarginalRateTaxScale()
+        >>> tax_scale.add_bracket(0, 0)
+        >>> tax_scale.add_bracket(100, 0.1)
+        >>> tax_base = array([0, 150])
+        >>> tax_scale.marginal_rates(tax_base)
+        [0.0, 0.1]
+        """
+        bracket_indices = self.bracket_indices(
+            tax_base,
+            factor,
+            round_base_decimals,
+        )
+
+        return numpy.array(self.rates)[bracket_indices]
+
+    def rate_from_bracket_indice(
+        self,
+        bracket_indice: numpy.int16,
+    ) -> numpy.float32:
+        """Compute the relevant tax rates for the given bracket indices.
+
+        :param: ndarray bracket_indice: Array of the bracket indices.
+
+        :returns: Floating array with relevant tax rates
+                  for the given bracket indices.
+
+        For instance:
+
+        >>> import numpy
+        >>> tax_scale = MarginalRateTaxScale()
+        >>> tax_scale.add_bracket(0, 0)
+        >>> tax_scale.add_bracket(200, 0.1)
+        >>> tax_scale.add_bracket(500, 0.25)
+        >>> tax_base = numpy.array([50, 1_000, 250])
+        >>> bracket_indice = tax_scale.bracket_indices(tax_base)
+        >>> tax_scale.rate_from_bracket_indice(bracket_indice)
+        array([0.  , 0.25, 0.1 ])
+        """
+        if bracket_indice.max() > len(self.rates) - 1:
+            msg = (
+                f"bracket_indice parameter ({bracket_indice}) "
+                f"contains one or more bracket indice which is unavailable "
+                f"inside current {self.__class__.__name__} :\n"
+                f"{self}"
+            )
+            raise IndexError(
+                msg,
+            )
+
+        return numpy.array(self.rates)[bracket_indice]
+
+    def rate_from_tax_base(
+        self,
+        tax_base: NumericalArray,
+    ) -> numpy.float32:
+        """Compute the relevant tax rates for the given tax bases.
+
+        :param: ndarray tax_base: Array of the tax bases.
+
+        :returns: Floating array with relevant tax rates
+                  for the given tax bases.
+
+        For instance:
+
+        >>> import numpy
+        >>> tax_scale = MarginalRateTaxScale()
+        >>> tax_scale.add_bracket(0, 0)
+        >>> tax_scale.add_bracket(200, 0.1)
+        >>> tax_scale.add_bracket(500, 0.25)
+        >>> tax_base = numpy.array([1_000, 50, 450])
+        >>> tax_scale.rate_from_tax_base(tax_base)
+        array([0.25, 0.  , 0.1 ])
+        """
+        return self.rate_from_bracket_indice(self.bracket_indices(tax_base))
+
+    def inverse(self) -> MarginalRateTaxScale:
+        """Returns a new instance of MarginalRateTaxScale.
+
+        Invert a taxscale:
+
+            Assume tax_scale composed of bracket whose thresholds are expressed
+            in terms of gross revenue.
+
+            The inverse is another MarginalRateTaxScale whose thresholds are
+            expressed in terms of net revenue.
+
+            If net = gross_revenue - tax_scale.calc(gross_revenue)
+            Then gross = tax_scale.inverse().calc(net)
+        """
+        # Threshold of net revenue.
+        net_threshold: int = 0
+
+        # Threshold of gross revenue.
+        threshold: int
+
+        # The intercept of the segments of the different thresholds in a
+        # representation of taxable revenue as a piecewise linear function
+        # of gross revenue.
+        theta: int
+
+        # Actually 1 / (1 - global_rate)
+        inverse = self.__class__(
+            name=str(self.name) + "'",
+            option=self.option,
+            unit=self.unit,
+        )
+
+        for threshold, rate in zip(self.thresholds, self.rates):
+            if threshold == 0:
+                previous_rate = 0
+                theta = 0
+
+            # We calculate the taxable revenue threshold of the considered
+            # bracket.
+            net_threshold = (1 - previous_rate) * threshold + theta
+            inverse.add_bracket(net_threshold, 1 / (1 - rate))
+            theta = (rate - previous_rate) * threshold + theta
+            previous_rate = rate
+
+        return inverse
+
+    def scale_tax_scales(self, factor: float) -> MarginalRateTaxScale:
+        """Scale all the MarginalRateTaxScales in the node."""
+        scaled_tax_scale = self.copy()
+        return scaled_tax_scale.multiply_thresholds(factor)
+
+    def to_average(self) -> taxscales.LinearAverageRateTaxScale:
+        average_tax_scale = taxscales.LinearAverageRateTaxScale(
+            name=self.name,
+            option=self.option,
+            unit=self.unit,
+        )
+
+        average_tax_scale.add_bracket(0, 0)
+
+        if self.thresholds:
+            i = 0
+            previous_threshold = self.thresholds[0]
+            previous_rate = self.rates[0]
+
+            for threshold, rate in itertools.islice(
+                zip(self.thresholds, self.rates),
+                1,
+                None,
+            ):
+                i += previous_rate * (threshold - previous_threshold)
+                average_tax_scale.add_bracket(threshold, i / threshold)
+                previous_threshold = threshold
+                previous_rate = rate
+
+            average_tax_scale.add_bracket(float("Inf"), rate)
+
+        return average_tax_scale