OpenFisca-Core 44.3.0__tar.gz → 44.6.0__tar.gz

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/CHANGELOG.md

@@ -1,18 +1,12 @@
 # Changelog
 
-## 44.3.0
+## 44.6.0
 
-#### New Features
-
-- **Generic Entity Links (Phase 1-6)**: Introduced a new Liam2-inspired generic entity linking system avoiding rigid hierarchies like `Person -> Household`.
-  - Added new `Many2OneLink` and `One2ManyLink` models to create powerful inter-entity networks (e.g., `Person -> Employer`).
-  - Added implicit links directly binding members arrays. This powers the new `population.links` property natively inside `TaxBenefitSystem.instantiate_entities()`.
-  - Full capability to chain relationships via python: `person.mother.household.get("rent", period)`.
-  - Powerful vectorized declarative aggregations out-of-the-box (e.g., `households.persons.sum("salary", period, condition=is_female)`).
-
-#### Technical Changes
+#### Technical changes
 
-- Backward compatibility is 100% maintained. Existing syntax via Projectors natively redirects to implicit links via modified `__getattr__`.
+- Revert the codebase to commit `8d26af3` to align the repository with the currently published `44.2.2` baseline on PyPI.
+- Mark versions `44.3.0`, `44.4.0`, `44.4.1`, and `44.5.0` as yanked.
+- Bump version to `44.6.0` to restore continuous deployment from this reverted baseline.
 
 ## 44.2.2
 

{openfisca_core-44.3.0 → openfisca_core-44.6.0/OpenFisca_Core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenFisca-Core
-Version: 44.3.0
+Version: 44.6.0
 Summary: A versatile microsimulation free software
 Home-page: https://github.com/openfisca/openfisca-core
 Author: OpenFisca Team

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/OpenFisca_Core.egg-info/SOURCES.txt

@@ -78,19 +78,6 @@ openfisca_core/indexed_enums/types.py
 openfisca_core/indexed_enums/tests/__init__.py
 openfisca_core/indexed_enums/tests/test_enum.py
 openfisca_core/indexed_enums/tests/test_enum_array.py
-openfisca_core/links/__init__.py
-openfisca_core/links/implicit.py
-openfisca_core/links/link.py
-openfisca_core/links/many2one.py
-openfisca_core/links/one2many.py
-openfisca_core/links/tests/__init__.py
-openfisca_core/links/tests/test_benchmark.py
-openfisca_core/links/tests/test_edge_cases.py
-openfisca_core/links/tests/test_implicit.py
-openfisca_core/links/tests/test_integration.py
-openfisca_core/links/tests/test_many2one.py
-openfisca_core/links/tests/test_one2many.py
-openfisca_core/links/tests/test_one2many_logic.py
 openfisca_core/parameters/__init__.py
 openfisca_core/parameters/at_instant_like.py
 openfisca_core/parameters/config.py

{openfisca_core-44.3.0/OpenFisca_Core.egg-info → openfisca_core-44.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenFisca-Core
-Version: 44.3.0
+Version: 44.6.0
 Summary: A versatile microsimulation free software
 Home-page: https://github.com/openfisca/openfisca-core
 Author: OpenFisca Team

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/entities/_core_entity.py

@@ -47,9 +47,6 @@ class CoreEntity:
     #: A ``TaxBenefitSystem`` instance.
     _tax_benefit_system: None | t.TaxBenefitSystem = None
 
-    #: Named links to other entities (Many2One, One2Many, etc.).
-    _links: dict
-
     @abc.abstractmethod
     def __init__(self, *__args: object, **__kwargs: object) -> None: ...
 
@@ -60,43 +57,6 @@ class CoreEntity:
         """A ``CoreEntity`` belongs to a ``TaxBenefitSystem``."""
         self._tax_benefit_system = tax_benefit_system
 
-    # -- Link management --------------------------------------------------
-
-    def add_link(self, link) -> None:
-        """Register a named link on this entity.
-
-        Args:
-            link: A ``Link`` instance (Many2OneLink, One2ManyLink, etc.).
-
-        Example::
-
-            from openfisca_core.links import Many2OneLink
-
-            mother = Many2OneLink(
-                name="mother",
-                link_field="mother_id",
-                target_entity_key="person",
-            )
-            person_entity.add_link(mother)
-
-        """
-        if not hasattr(self, "_links") or self._links is None:
-            self._links = {}
-        self._links[link.name] = link
-
-    def get_link(self, name: str):
-        """Retrieve a link by name, or ``None`` if not found."""
-        if not hasattr(self, "_links") or self._links is None:
-            return None
-        return self._links.get(name)
-
-    @property
-    def links(self) -> dict:
-        """All links registered on this entity."""
-        if not hasattr(self, "_links") or self._links is None:
-            self._links = {}
-        return self._links
-
     def get_variable(
         self,
         variable_name: t.VariableName,

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/indexed_enums/enum_array.py

@@ -266,7 +266,8 @@ class EnumArray(t.EnumArray):
         result: t.ObjArray
         if self.possible_values is None:
             msg = (
-                f"The possible values of the {self.__class__.__name__} are not defined."
+                f"The possible values of the {self.__class__.__name__} are "
+                f"not defined."
             )
             raise TypeError(msg)
         array = self.reshape(1).astype(t.EnumDType) if self.ndim == 0 else self
@@ -300,7 +301,8 @@ class EnumArray(t.EnumArray):
         result: t.StrArray
         if self.possible_values is None:
             msg = (
-                f"The possible values of the {self.__class__.__name__} are not defined."
+                f"The possible values of the {self.__class__.__name__} are "
+                f"not defined."
             )
             raise TypeError(msg)
         array = self.reshape(1).astype(t.EnumDType) if self.ndim == 0 else self

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/populations/group_population.py

@@ -96,42 +96,16 @@ class GroupPopulation(Population):
             None,
         )
 
-    #  Filtering helpers
-
-    def _build_member_mask(self, role=None, condition=None):
-        """Build a combined boolean mask from role and condition filters.
-
-        Returns None if no filtering is needed (both are None), otherwise
-        returns a boolean array of length ``members.count``.
-        """
-        if role is None and condition is None:
-            return None
-
-        mask = numpy.ones(self.members.count, dtype=bool)
-
-        if role is not None:
-            role_filter = self.members.has_role(role)
-            mask &= role_filter
-
-        if condition is not None:
-            mask &= condition
-
-        return mask
-
     #  Aggregation persons -> entity
 
     @projectors.projectable
-    def sum(self, array, role=None, condition=None):
+    def sum(self, array, role=None):
         """Return the sum of ``array`` for the members of the entity.
 
         ``array`` must have the dimension of the number of persons in the simulation
 
         If ``role`` is provided, only the entity member with the given role are taken into account.
 
-        If ``condition`` is provided (a boolean array of the same size as the
-        person population), only members for whom the condition is ``True`` are
-        taken into account.  ``role`` and ``condition`` can be combined.
-
         Example:
         >>> salaries = household.members(
         ...     "salary", "2018-01"
@@ -142,27 +116,23 @@ class GroupPopulation(Population):
         """
         self.entity.check_role_validity(role)
         self.members.check_array_compatible_with_entity(array)
-        mask = self._build_member_mask(role, condition)
-        if mask is not None:
+        if role is not None:
+            role_filter = self.members.has_role(role)
             return numpy.bincount(
-                self.members_entity_id[mask],
-                weights=array[mask],
+                self.members_entity_id[role_filter],
+                weights=array[role_filter],
                 minlength=self.count,
             )
         return numpy.bincount(self.members_entity_id, weights=array)
 
     @projectors.projectable
-    def any(self, array, role=None, condition=None):
+    def any(self, array, role=None):
         """Return ``True`` if ``array`` is ``True`` for any members of the entity.
 
         ``array`` must have the dimension of the number of persons in the simulation
 
         If ``role`` is provided, only the entity member with the given role are taken into account.
 
-        If ``condition`` is provided (a boolean array of the same size as the
-        person population), only members for whom the condition is ``True`` are
-        taken into account.  ``role`` and ``condition`` can be combined.
-
         Example:
         >>> salaries = household.members(
         ...     "salary", "2018-01"
@@ -171,18 +141,16 @@ class GroupPopulation(Population):
         >>> array([True])
 
         """
-        sum_in_entity = self.sum(array, role=role, condition=condition)
+        sum_in_entity = self.sum(array, role=role)
         return sum_in_entity > 0
 
     @projectors.projectable
-    def reduce(self, array, reducer, neutral_element, role=None, condition=None):
+    def reduce(self, array, reducer, neutral_element, role=None):
         self.members.check_array_compatible_with_entity(array)
         self.entity.check_role_validity(role)
         position_in_entity = self.members_position
-        mask = self._build_member_mask(role, condition)
-        if mask is None:
-            mask = True  # scalar True broadcasts; preserves old upcast behavior
-        filtered_array = numpy.where(mask, array, neutral_element)
+        role_filter = self.members.has_role(role) if role is not None else True
+        filtered_array = numpy.where(role_filter, array, neutral_element)
 
         result = self.filled_array(
             neutral_element,
@@ -199,17 +167,13 @@ class GroupPopulation(Population):
         return result
 
     @projectors.projectable
-    def all(self, array, role=None, condition=None):
+    def all(self, array, role=None):
         """Return ``True`` if ``array`` is ``True`` for all members of the entity.
 
         ``array`` must have the dimension of the number of persons in the simulation
 
         If ``role`` is provided, only the entity member with the given role are taken into account.
 
-        If ``condition`` is provided (a boolean array of the same size as the
-        person population), only members for whom the condition is ``True`` are
-        taken into account.  ``role`` and ``condition`` can be combined.
-
         Example:
         >>> salaries = household.members(
         ...     "salary", "2018-01"
@@ -223,21 +187,16 @@ class GroupPopulation(Population):
             reducer=numpy.logical_and,
             neutral_element=True,
             role=role,
-            condition=condition,
         )
 
     @projectors.projectable
-    def max(self, array, role=None, condition=None):
+    def max(self, array, role=None):
         """Return the maximum value of ``array`` for the entity members.
 
         ``array`` must have the dimension of the number of persons in the simulation
 
         If ``role`` is provided, only the entity member with the given role are taken into account.
 
-        If ``condition`` is provided (a boolean array of the same size as the
-        person population), only members for whom the condition is ``True`` are
-        taken into account.  ``role`` and ``condition`` can be combined.
-
         Example:
         >>> salaries = household.members(
         ...     "salary", "2018-01"
@@ -251,21 +210,16 @@ class GroupPopulation(Population):
             reducer=numpy.maximum,
             neutral_element=-numpy.inf,
             role=role,
-            condition=condition,
         )
 
     @projectors.projectable
-    def min(self, array, role=None, condition=None):
+    def min(self, array, role=None):
         """Return the minimum value of ``array`` for the entity members.
 
         ``array`` must have the dimension of the number of persons in the simulation
 
         If ``role`` is provided, only the entity member with the given role are taken into account.
 
-        If ``condition`` is provided (a boolean array of the same size as the
-        person population), only members for whom the condition is ``True`` are
-        taken into account.  ``role`` and ``condition`` can be combined.
-
         Example:
         >>> salaries = household.members(
         ...     "salary", "2018-01"
@@ -283,18 +237,13 @@ class GroupPopulation(Population):
             reducer=numpy.minimum,
             neutral_element=numpy.inf,
             role=role,
-            condition=condition,
         )
 
     @projectors.projectable
-    def nb_persons(self, role=None, condition=None):
+    def nb_persons(self, role=None):
         """Returns the number of persons contained in the entity.
 
         If ``role`` is provided, only the entity member with the given role are taken into account.
-
-        If ``condition`` is provided (a boolean array of the same size as the
-        person population), only members for whom the condition is ``True`` are
-        counted.  ``role`` and ``condition`` can be combined.
         """
         if role:
             if role.subroles:
@@ -303,9 +252,7 @@ class GroupPopulation(Population):
                 )
             else:
                 role_condition = self.members_role == role
-            return self.sum(role_condition, condition=condition)
-        if condition is not None:
-            return self.sum(condition.astype(float)).astype(int)
+            return self.sum(role_condition)
         return numpy.bincount(self.members_entity_id)
 
     # Projection person -> entity

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/populations/population.py

@@ -24,9 +24,6 @@ class Population(CorePopulation):
         return result
 
     def __getattr__(self, attribute: str) -> projectors.Projector:
-        if hasattr(self, "links") and attribute in self.links:
-            return self.links[attribute]
-
         projector: projectors.Projector | None
         projector = projectors.get_projector_from_shortcut(self, attribute)
 
@@ -114,10 +111,11 @@ class Population(CorePopulation):
 
         """
         # If entity is for instance 'person.household', we get the reference entity 'household' behind the projector
-        if isinstance(entity, projectors.Projector):
-            entity = entity.reference_entity
-        elif hasattr(entity, "_target_population"):  # Handle new Link system
-            entity = entity._target_population
+        entity = (
+            entity
+            if not isinstance(entity, projectors.Projector)
+            else entity.reference_entity
+        )
 
         positions = entity.members_position
         biggest_entity_size = numpy.max(positions) + 1

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/simulations/simulation.py

@@ -47,7 +47,6 @@ class Simulation:
         self.persons = self.populations[tax_benefit_system.person_entity.key]
         self.link_to_entities_instances()
         self.create_shortcuts()
-        self._resolve_links()
 
         self.invalidated_caches = set()
 
@@ -83,53 +82,6 @@ class Simulation:
             # create shortcut simulation.person and simulation.household (for instance)
             setattr(self, population.entity.key, population)
 
-    def _resolve_links(self) -> None:
-        """Attach and resolve all links declared on every entity.
-
-        This also auto-generates implicit links for each GroupEntity:
-        - A Many2One link on the person entity (e.g. ``person.household``)
-        - A One2Many link on the group entity (e.g. ``household.members``)
-
-        This is called once at ``__init__`` time, after
-        ``link_to_entities_instances`` and ``create_shortcuts``.
-        """
-        from openfisca_core.links.implicit import (
-            ImplicitMany2OneLink,
-            ImplicitOne2ManyLink,
-        )
-        from openfisca_core.populations.group_population import GroupPopulation
-
-        person_entity = self.persons.entity
-
-        # Auto-generate implicit links
-        for population in self.populations.values():
-            if not isinstance(population, GroupPopulation):
-                continue
-            group_key = population.entity.key
-
-            # person -> group (Many2One)
-            if not person_entity.get_link(group_key):
-                m2o = ImplicitMany2OneLink(group_key)
-                person_entity.add_link(m2o)
-
-            # group -> persons (One2Many)
-            o2m_name = person_entity.plural
-            if not population.entity.get_link(o2m_name):
-                o2m = ImplicitOne2ManyLink(o2m_name, group_key)
-                population.entity.add_link(o2m)
-
-        from copy import copy
-
-        # Attach and resolve all links, making a simulation-local copy
-        for _key, population in self.populations.items():
-            entity = population.entity
-            population.links = {}
-            for name, link in entity.links.items():
-                bound_link = copy(link)
-                bound_link.attach(population)
-                bound_link.resolve(self.populations)
-                population.links[name] = bound_link
-
     @property
     def data_storage_dir(self):
         """Temporary folder used to store intermediate calculation data in case the memory is saturated."""

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/taxscales/abstract_rate_tax_scale.py

@@ -36,7 +36,7 @@ class AbstractRateTaxScale(RateTaxScaleLike):
         tax_base: NumericalArray,
         right: bool,
     ) -> typing.NoReturn:
-        msg = f"Method 'calc' is not implemented for {self.__class__.__name__}"
+        msg = "Method 'calc' is not implemented for " f"{self.__class__.__name__}"
         raise NotImplementedError(
             msg,
         )

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/taxscales/abstract_tax_scale.py

@@ -32,7 +32,7 @@ class AbstractTaxScale(TaxScaleLike):
         super().__init__(name, option, unit)
 
     def __repr__(self) -> typing.NoReturn:
-        msg = f"Method '__repr__' is not implemented for {self.__class__.__name__}"
+        msg = "Method '__repr__' is not implemented for " f"{self.__class__.__name__}"
         raise NotImplementedError(
             msg,
         )
@@ -42,7 +42,7 @@ class AbstractTaxScale(TaxScaleLike):
         tax_base: NumericalArray,
         right: bool,
     ) -> typing.NoReturn:
-        msg = f"Method 'calc' is not implemented for {self.__class__.__name__}"
+        msg = "Method 'calc' is not implemented for " f"{self.__class__.__name__}"
         raise NotImplementedError(
             msg,
         )

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/openfisca_core/taxscales/tax_scale_like.py

@@ -36,13 +36,13 @@ class TaxScaleLike(abc.ABC):
         self.thresholds = []
 
     def __eq__(self, _other: object) -> typing.NoReturn:
-        msg = f"Method '__eq__' is not implemented for {self.__class__.__name__}"
+        msg = "Method '__eq__' is not implemented for " f"{self.__class__.__name__}"
         raise NotImplementedError(
             msg,
         )
 
     def __ne__(self, _other: object) -> typing.NoReturn:
-        msg = f"Method '__ne__' is not implemented for {self.__class__.__name__}"
+        msg = "Method '__ne__' is not implemented for " f"{self.__class__.__name__}"
         raise NotImplementedError(
             msg,
         )

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/pyproject.toml

@@ -11,4 +11,4 @@ ignore-words-list = [
     "impot",
     "treshold",
 ]
-skip = "./venv,./docs/implementation"
+skip = "./venv"

{openfisca_core-44.3.0 → openfisca_core-44.6.0}/setup.py

@@ -84,7 +84,7 @@ dev_requirements = [
 
 setup(
     name="OpenFisca-Core",
-    version="44.3.0",
+    version="44.6.0",
     author="OpenFisca Team",
     author_email="contact@openfisca.org",
     classifiers=[

openfisca_core-44.3.0/openfisca_core/links/__init__.py

@@ -1,36 +0,0 @@
-"""Links between entities (Many2One, One2Many, chaining).
-
-This module implements a generic link system inspired by LIAM2, enriched
-with OpenFisca's role semantics.  Links are orthogonal to the existing
-GroupEntity/Projector machinery: current code keeps working unchanged,
-and links provide additional capabilities (intra-entity links, chaining,
-arbitrary named links).
-
-Usage in a country package::
-
-    from openfisca_core.links import Many2OneLink, One2ManyLink
-
-    # Declare a person→person link (intra-entity)
-    mother = Many2OneLink(
-        name="mother",
-        link_field="mother_id",
-        target_entity_key="person",
-    )
-
-    # Declare a person→employer link (inter-entity)
-    employer = Many2OneLink(
-        name="employer",
-        link_field="employer_id",
-        target_entity_key="employer",
-    )
-"""
-
-from .link import Link
-from .many2one import Many2OneLink
-from .one2many import One2ManyLink
-
-__all__ = [
-    "Link",
-    "Many2OneLink",
-    "One2ManyLink",
-]

openfisca_core-44.3.0/openfisca_core/links/implicit.py

@@ -1,73 +0,0 @@
-"""Implicit links dynamically inferred from OpenFisca's GroupPopulation system."""
-
-from __future__ import annotations
-
-import numpy
-
-from .many2one import Many2OneLink
-from .one2many import One2ManyLink
-
-
-class ImplicitMany2OneLink(Many2OneLink):
-    """A person → group link using GroupPopulation's internal arrays.
-
-    This bypasses the usual Variable lookup (``simulation.calculate``)
-    and directly reads ``members_entity_id`` and ``members_role`` from
-    the target GroupPopulation.
-    """
-
-    def __init__(self, group_entity_key: str):
-        super().__init__(
-            name=group_entity_key,
-            link_field="",  # Not used
-            target_entity_key=group_entity_key,
-        )
-
-    def _get_target_ids(self, period) -> numpy.ndarray:
-        return self._target_population.members_entity_id
-
-    @property
-    def role(self) -> numpy.ndarray | None:
-        return self._target_population.members_role
-
-    def _project_implicit(self, result: numpy.ndarray) -> numpy.ndarray:
-        # Fully compatible with old Projector logic
-        return self._target_population.project(result)
-
-
-class ImplicitOne2ManyLink(One2ManyLink):
-    """A group → person link using GroupPopulation's internal arrays."""
-
-    def __init__(self, name: str, group_entity_key: str):
-        super().__init__(
-            name=name,
-            link_field="",  # Not used
-            target_entity_key="person",  # The target of the O2M is persons
-        )
-        self._group_entity_key = group_entity_key
-
-    def _source_rows(self, period) -> numpy.ndarray:
-        # For a group->person O2M, the source is the group, the target is the person.
-        # members_entity_id is an array of length person.count, containing the group index.
-        # So members_entity_id IS the array of source rows for each target member.
-        return self._source_population.members_entity_id
-
-    def _apply_filters(self, period, values, role, condition):
-        source_rows = self._source_rows(period)
-        mask = numpy.ones(len(source_rows), dtype=bool)
-
-        if role is not None:
-            roles = self._source_population.members_role
-            mask &= roles == role
-
-        if condition is not None:
-            mask &= condition
-
-        source_rows = source_rows[mask]
-        values = values[mask]
-
-        valid = source_rows >= 0
-        return source_rows[valid], values[valid]
-
-
-__all__ = ["ImplicitMany2OneLink", "ImplicitOne2ManyLink"]