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

openfisca_core/scripts/remove_fuzzy.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+# remove_fuzzy.py : Remove the fuzzy attribute in xml files and add END tags.
+# See https://github.com/openfisca/openfisca-core/issues/437
+
+import datetime
+import re
+import sys
+
+import numpy
+
+assert len(sys.argv) == 2
+filename = sys.argv[1]
+
+with open(filename) as f:
+    lines = f.readlines()
+
+
+# Remove fuzzy
+
+lines_2 = [line.replace(' fuzzy="true"', "") for line in lines]
+
+regex_indent = r"^(\s*)<VALUE "
+regex_fin = r' fin="([0-9\-]+)"'
+regex_iso8601 = r"([0-9]+)-([0-9]+)-([0-9]+)"
+one_day = datetime.timedelta(days=1)
+
+lines_3 = []
+for line in lines_2:
+    if ' fin="' in line:
+        m_indent = re.search(regex_indent, line)
+        spaces = m_indent.groups()[0]
+
+        m_fin = re.search(regex_fin, line)
+        fin_date = m_fin.groups()[0]
+        fin_left, fin_right = m_fin.span()
+
+        m_date = re.match(regex_iso8601, fin_date)
+        year_str, month_str, day_str = m_date.groups()
+        date_parsed = datetime.date(int(year_str), int(month_str), int(day_str))
+        date_parsed += one_day
+        fin_date = date_parsed.isoformat()
+
+        lines_3.append(spaces + '<END deb="' + fin_date + '" />\n')
+        lines_3.append(line[:fin_left] + line[fin_right:])
+    else:
+        lines_3.append(line)
+
+
+# Remove useless END tags
+
+regex_code = "<(CODE|SEUIL|TAUX|ASSIETTE)"
+regex_code_end = "</(CODE|SEUIL|TAUX|ASSIETTE)"
+regex_value = "<VALUE"
+regex_end = "<END"
+
+bool_code = [bool(re.search(regex_code, line)) for line in lines_3]
+
+bool_code_end = [bool(re.search(regex_code_end, line)) for line in lines_3]
+
+bool_value = [bool(re.search(regex_value, line)) for line in lines_3]
+
+bool_end = [bool(re.search(regex_end, line)) for line in lines_3]
+
+
+index_code = [i + 1 for i, x in enumerate(bool_code) if x]
+index_code_end = [i for i, x in enumerate(bool_code_end) if x]
+
+assert len(index_code) == len(index_code_end)
+
+position_code = list(zip(index_code, index_code_end))
+
+
+end_to_remove = []
+regex_deb = r' deb="([0-9\-]+)"'
+
+for code_begining, code_end in position_code:
+    deb_list = []
+
+    for local_i, line in enumerate(lines_3[code_begining:code_end]):
+        i = local_i + code_begining
+
+        m_deb = re.search(regex_deb, line)
+        if m_deb:
+            deb_tmp = m_deb.groups()[0]
+            deb_list.append(deb_tmp)
+        else:
+            deb_list.append(None)
+
+    for repr_deb in set(deb_list) - {None}:
+        part_list = [
+            local_i + code_begining
+            for local_i, deb in enumerate(deb_list)
+            if deb == repr_deb
+        ]
+
+        assert len(part_list) <= 2
+
+        if len(part_list) == 2:
+            i1 = part_list[0]
+            i2 = part_list[1]
+            if bool_value[i1]:
+                assert not bool_value[i2]
+                assert not bool_end[i1]
+                assert bool_end[i2]
+                i_value = i1
+                i_end = i2
+            else:
+                assert bool_value[i2]
+                assert bool_end[i1]
+                assert not bool_end[i2]
+                i_value = i2
+                i_end = i1
+
+            end_to_remove.append(i_end)
+
+
+end_to_remove_set = set(end_to_remove)
+
+
+lines_4 = [line for j, line in enumerate(lines_3) if j not in end_to_remove_set]
+
+# Order by "deb"
+
+bool_code = [bool(re.search(regex_code, line)) for line in lines_4]
+
+bool_code_end = [bool(re.search(regex_code_end, line)) for line in lines_4]
+
+
+index_code = [j + 1 for j, x in enumerate(bool_code) if x]
+index_code_end = [j for j, x in enumerate(bool_code_end) if x]
+
+assert len(index_code) == len(index_code_end)
+
+position_code = list(zip(index_code, index_code_end))
+
+i = 0
+lines_5 = []
+for code_begining, code_end in position_code:
+    while i < code_begining:
+        lines_5.append(lines_4[i])
+        i += 1
+
+    comment_list = []
+    deb_list = []
+
+    for local_i, line in enumerate(lines_4[code_begining:code_end]):
+        i = local_i + code_begining
+
+        m_deb = re.search(regex_deb, line)
+        if m_deb:
+            deb_tmp = m_deb.groups()[0]
+            deb_list.append(deb_tmp)
+        else:
+            comment_list.append(local_i)
+            deb_list.append("z")
+
+    lines_5 += [lines_4[local_i + code_begining] for local_i in comment_list]
+
+    order = numpy.argsort(deb_list)[::-1]
+    lines_5 += [
+        lines_4[local_i + code_begining]
+        for local_i in order
+        if deb_list[local_i] != "z"
+    ]
+
+    i += 1
+while i < len(lines_4):
+    lines_5.append(lines_4[i])
+    i += 1
+
+
+# Remove duplicate values
+
+regex_value2 = r'^(?: )*<VALUE deb="\d{4}-\d{2}-\d{2}" valeur="((?:\d|.)+)" \/>\n$'
+
+bool_code = [bool(re.search(regex_code, line)) for line in lines_5]
+
+bool_code_end = [bool(re.search(regex_code_end, line)) for line in lines_5]
+
+list_value = []
+for line in lines_5:
+    m = re.match(regex_value2, line)
+    if m:
+        list_value.append(m.groups()[0])
+    else:
+        list_value.append(None)
+
+
+index_code = [j + 1 for j, x in enumerate(bool_code) if x]
+index_code_end = [j for j, x in enumerate(bool_code_end) if x]
+
+assert len(index_code) == len(index_code_end)
+
+position_code = list(zip(index_code, index_code_end))
+
+to_remove = []
+for i in range(len(lines_5) - 1):
+    if (
+        (list_value[i] is not None)
+        and (list_value[i + 1] is not None)
+        and (list_value[i] == list_value[i + 1])
+    ):
+        to_remove.append(i)
+
+to_remove_set = set(to_remove)
+
+lines_6 = [line for j, line in enumerate(lines_5) if j not in to_remove_set]
+
+# Write
+
+with open(filename, "w") as f:
+    for line in lines_6:
+        f.write(line)

openfisca_core/scripts/run_test.py

@@ -0,0 +1,51 @@
+import logging
+import os
+import sys
+
+from openfisca_core.scripts import build_tax_benefit_system
+from openfisca_core.tools.test_runner import run_tests
+
+
+def main(parser) -> None:
+    args = parser.parse_args()
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.WARNING,
+        stream=sys.stdout,
+    )
+
+    tax_benefit_system = build_tax_benefit_system(
+        args.country_package,
+        args.extensions,
+        args.reforms,
+    )
+
+    options = {
+        "country_package": args.country_package,
+        "extensions": args.extensions,
+        "reforms": args.reforms,
+        "pdb": args.pdb,
+        "performance_graph": args.performance_graph,
+        "performance_tables": args.performance_tables,
+        "verbose": args.verbose,
+        "aggregate": args.aggregate,
+        "max_depth": args.max_depth,
+        "name_filter": args.name_filter,
+        "only_variables": args.only_variables,
+        "ignore_variables": args.ignore_variables,
+        "ignore_default": args.ignore_default,
+    }
+
+    paths = [os.path.abspath(path) for path in args.path]
+
+    # Parallel mode
+    if args.in_parallel:
+        from openfisca_core.tools.test_runner import run_tests_in_parallel
+
+        return sys.exit(
+            run_tests_in_parallel(
+                tax_benefit_system, paths, options, args.num_workers, args.verbose
+            )
+        )
+
+    # Default serial mode
+    sys.exit(run_tests(tax_benefit_system, paths, options))

openfisca_core/scripts/simulation_generator.py

@@ -0,0 +1,90 @@
+import random
+
+import numpy
+
+from openfisca_core.simulations import Simulation
+
+
+def make_simulation(tax_benefit_system, nb_persons, nb_groups, **kwargs):
+    """Generate a simulation containing nb_persons persons spread in nb_groups groups.
+
+    Example:
+    >>> from openfisca_core.scripts.simulation_generator import make_simulation
+    >>> from openfisca_france import CountryTaxBenefitSystem
+    >>> tbs = CountryTaxBenefitSystem()
+    >>> simulation = make_simulation(
+    ...     tbs, 400, 100
+    ... )  # Create a simulation with 400 persons, spread among 100 families
+    >>> simulation.calculate("revenu_disponible", 2017)
+
+    """
+    simulation = Simulation(tax_benefit_system=tax_benefit_system, **kwargs)
+    simulation.persons.ids = numpy.arange(nb_persons)
+    simulation.persons.count = nb_persons
+    adults = [0, *sorted(random.sample(range(1, nb_persons), nb_groups - 1))]
+
+    members_entity_id = numpy.empty(nb_persons, dtype=int)
+
+    # A legacy role is an index that every person within an entity has. For instance, the 'demandeur' has legacy role 0, the 'conjoint' 1, the first 'child' 2, the second 3, etc.
+    members_legacy_role = numpy.empty(nb_persons, dtype=int)
+
+    id_group = -1
+    for id_person in range(nb_persons):
+        if id_person in adults:
+            id_group += 1
+            legacy_role = 0
+        else:
+            legacy_role = 2 if legacy_role == 0 else legacy_role + 1
+        members_legacy_role[id_person] = legacy_role
+        members_entity_id[id_person] = id_group
+
+    for entity in simulation.populations.values():
+        if not entity.is_person:
+            entity.members_entity_id = members_entity_id
+            entity.count = nb_groups
+            entity.members_role = numpy.where(
+                members_legacy_role == 0,
+                entity.flattened_roles[0],
+                entity.flattened_roles[-1],
+            )
+    return simulation
+
+
+def randomly_init_variable(
+    simulation,
+    variable_name: str,
+    period,
+    max_value,
+    condition=None,
+) -> None:
+    """Initialise a variable with random values (from 0 to max_value) for the given period.
+    If a condition vector is provided, only set the value of persons or groups for which condition is True.
+
+    Example:
+    >>> from openfisca_core.scripts.simulation_generator import (
+    ...     make_simulation,
+    ...     randomly_init_variable,
+    ... )
+    >>> from openfisca_france import CountryTaxBenefitSystem
+    >>> tbs = CountryTaxBenefitSystem()
+    >>> simulation = make_simulation(
+    ...     tbs, 400, 100
+    ... )  # Create a simulation with 400 persons, spread among 100 families
+    >>> randomly_init_variable(
+    ...     simulation,
+    ...     "salaire_net",
+    ...     2017,
+    ...     max_value=50000,
+    ...     condition=simulation.persons.has_role(simulation.famille.DEMANDEUR),
+    ... )  # Randomly set a salaire_net for all persons between 0 and 50000?
+    >>> simulation.calculate("revenu_disponible", 2017)
+
+    """
+    if condition is None:
+        condition = True
+    variable = simulation.tax_benefit_system.get_variable(variable_name)
+    population = simulation.get_variable_population(variable_name)
+    value = (numpy.random.rand(population.count) * max_value * condition).astype(
+        variable.dtype,
+    )
+    simulation.set_input(variable_name, period, value)

openfisca_core/simulation_builder.py

@@ -0,0 +1,16 @@
+# The simulation builder module has been deprecated since X.X.X,
+# and will be removed in the future.
+#
+# Module's contents have been moved to the simulation module.
+#
+# The following are transitional imports to ensure non-breaking changes.
+# Could be deprecated in the next major release.
+
+from openfisca_core.simulations import (  # noqa: F401
+    Simulation,
+    SimulationBuilder,
+    calculate_output_add,
+    calculate_output_divide,
+    check_type,
+    transform_to_strict_syntax,
+)

openfisca_core/simulations/__init__.py

@@ -0,0 +1,45 @@
+# Transitional imports to ensure non-breaking changes.
+# Could be deprecated in the next major release.
+#
+# How imports are being used today:
+#
+#   >>> from openfisca_core.module import symbol
+#
+# The previous example provokes cyclic dependency problems
+# that prevent us from modularizing the different components
+# of the library so to make them easier to test and to maintain.
+#
+# How could them be used after the next major release:
+#
+#   >>> from openfisca_core import module
+#   >>> module.symbol()
+#
+# And for classes:
+#
+#   >>> from openfisca_core.module import Symbol
+#   >>> Symbol()
+#
+# See: https://www.python.org/dev/peps/pep-0008/#imports
+
+from openfisca_core.errors import CycleError, NaNCreationError, SpiralError
+
+from .helpers import (
+    calculate_output_add,
+    calculate_output_divide,
+    check_type,
+    transform_to_strict_syntax,
+)
+from .simulation import Simulation
+from .simulation_builder import SimulationBuilder
+
+__all__ = [
+    "CycleError",
+    "NaNCreationError",
+    "Simulation",
+    "SimulationBuilder",
+    "SpiralError",
+    "calculate_output_add",
+    "calculate_output_divide",
+    "check_type",
+    "transform_to_strict_syntax",
+]

openfisca_core/simulations/_build_default_simulation.py

@@ -0,0 +1,158 @@
+"""This module contains the _BuildDefaultSimulation class."""
+
+from typing import Self
+
+import numpy
+
+from .simulation import Simulation
+from .typing import Entity, Population, TaxBenefitSystem
+
+
+class _BuildDefaultSimulation:
+    """Build a default simulation.
+
+    Args:
+        tax_benefit_system(TaxBenefitSystem): The tax-benefit system.
+        count(int): The number of periods.
+
+    Examples:
+        >>> from openfisca_core import entities, taxbenefitsystems
+
+        >>> role = {"key": "stray", "plural": "stray", "label": "", "doc": ""}
+        >>> single_entity = entities.Entity("dog", "dogs", "", "")
+        >>> group_entity = entities.GroupEntity("pack", "packs", "", "", [role])
+        >>> test_entities = [single_entity, group_entity]
+        >>> tax_benefit_system = taxbenefitsystems.TaxBenefitSystem(test_entities)
+        >>> count = 1
+        >>> builder = (
+        ...     _BuildDefaultSimulation(tax_benefit_system, count)
+        ...     .add_count()
+        ...     .add_ids()
+        ...     .add_members_entity_id()
+        ... )
+
+        >>> builder.count
+        1
+
+        >>> sorted(builder.populations.keys())
+        ['dog', 'pack']
+
+        >>> sorted(builder.simulation.populations.keys())
+        ['dog', 'pack']
+
+    """
+
+    #: The number of Population.
+    count: int
+
+    #: The built populations.
+    populations: dict[str, Population[Entity]]
+
+    #: The built simulation.
+    simulation: Simulation
+
+    def __init__(self, tax_benefit_system: TaxBenefitSystem, count: int) -> None:
+        self.count = count
+        self.populations = tax_benefit_system.instantiate_entities()
+        self.simulation = Simulation(tax_benefit_system, self.populations)
+
+    def add_count(self) -> Self:
+        """Add the number of Population to the simulation.
+
+        Returns:
+            _BuildDefaultSimulation: The builder.
+
+        Examples:
+            >>> from openfisca_core import entities, taxbenefitsystems
+
+            >>> role = {"key": "stray", "plural": "stray", "label": "", "doc": ""}
+            >>> single_entity = entities.Entity("dog", "dogs", "", "")
+            >>> group_entity = entities.GroupEntity("pack", "packs", "", "", [role])
+            >>> test_entities = [single_entity, group_entity]
+            >>> tax_benefit_system = taxbenefitsystems.TaxBenefitSystem(test_entities)
+            >>> count = 2
+            >>> builder = _BuildDefaultSimulation(tax_benefit_system, count)
+
+            >>> builder.add_count()
+            <..._BuildDefaultSimulation object at ...>
+
+            >>> builder.populations["dog"].count
+            2
+
+            >>> builder.populations["pack"].count
+            2
+
+        """
+        for population in self.populations.values():
+            population.count = self.count
+
+        return self
+
+    def add_ids(self) -> Self:
+        """Add the populations ids to the simulation.
+
+        Returns:
+            _BuildDefaultSimulation: The builder.
+
+        Examples:
+            >>> from openfisca_core import entities, taxbenefitsystems
+
+            >>> role = {"key": "stray", "plural": "stray", "label": "", "doc": ""}
+            >>> single_entity = entities.Entity("dog", "dogs", "", "")
+            >>> group_entity = entities.GroupEntity("pack", "packs", "", "", [role])
+            >>> test_entities = [single_entity, group_entity]
+            >>> tax_benefit_system = taxbenefitsystems.TaxBenefitSystem(test_entities)
+            >>> count = 2
+            >>> builder = _BuildDefaultSimulation(tax_benefit_system, count)
+
+            >>> builder.add_ids()
+            <..._BuildDefaultSimulation object at ...>
+
+            >>> builder.populations["dog"].ids
+            array([0, 1])
+
+            >>> builder.populations["pack"].ids
+            array([0, 1])
+
+        """
+        for population in self.populations.values():
+            population.ids = numpy.array(range(self.count))
+
+        return self
+
+    def add_members_entity_id(self) -> Self:
+        """Add ???
+
+        Each SingleEntity has its own GroupEntity.
+
+        Returns:
+            _BuildDefaultSimulation: The builder.
+
+        Examples:
+            >>> from openfisca_core import entities, taxbenefitsystems
+
+            >>> role = {"key": "stray", "plural": "stray", "label": "", "doc": ""}
+            >>> single_entity = entities.Entity("dog", "dogs", "", "")
+            >>> group_entity = entities.GroupEntity("pack", "packs", "", "", [role])
+            >>> test_entities = [single_entity, group_entity]
+            >>> tax_benefit_system = taxbenefitsystems.TaxBenefitSystem(test_entities)
+            >>> count = 2
+            >>> builder = _BuildDefaultSimulation(tax_benefit_system, count)
+
+            >>> builder.add_members_entity_id()
+            <..._BuildDefaultSimulation object at ...>
+
+            >>> population = builder.populations["pack"]
+
+            >>> hasattr(population, "members_entity_id")
+            True
+
+            >>> population.members_entity_id
+            array([0, 1])
+
+        """
+        for population in self.populations.values():
+            if hasattr(population, "members_entity_id"):
+                population.members_entity_id = numpy.array(range(self.count))
+
+        return self