OpenFisca-Core 44.5.0__tar.gz → 44.7.0__tar.gz

{openfisca_core-44.5.0 → openfisca_core-44.7.0}/CHANGELOG.md

@@ -1,48 +1,18 @@
 # Changelog
 
-## 44.5.0
+## 44.7.0 [#1357](https://github.com/openfisca/openfisca-core/pull/1357)
 
 #### New features
 
-- Add `as_of` attribute to `Variable` for persistent vector variables.
-  - A variable declared with `as_of = True` (or `"start"` / `"end"`) stores its value at a given instant and automatically returns that value for any later period, until a new value is explicitly set — the vectorial analogue of OpenFisca parameters.
-  - `as_of = "start"` (default when `True`): lookup uses the start of the requested period as reference instant.
-  - `as_of = "end"`: lookup uses the end of the requested period (useful for annual variables like income tax).
-  - Lookup is O(log P) via `bisect` on a sorted instants index.
-  - Reference sharing: when consecutive stored values are identical, the same array object is reused, reducing memory usage for stable variables (e.g. `marital_status`, `housing_occupancy_status`).
-  - Stored arrays are read-only (`writeable=False`) to prevent accidental in-place mutation.
-  - Combining `as_of` with `set_input` dispatch helpers raises a `ValueError` at variable definition time.
+- Manage list parameter in Excel reform
 
-## 44.4.0 [#1364](https://github.com/openfisca/openfisca-core/pull/1364)
-
-#### New features
-
-- **Entity links**: role-based and positional accessors, and dynamic population period-index helpers.
-  - `Many2OneLink.get_by_role(variable_name, period, role_value=...)`, `One2ManyLink.get_by_role(...)` and `ImplicitOne2ManyLink.get_by_role(...)`.
-  - `Many2OneLink.rank(variable_name, period)` (and on chained getter, e.g. `person.links["mother"].household.rank("age", period)`).
-  - `One2ManyLink.nth(n, variable_name, period, role=..., condition=...)` for the n-th target member per source.
-  - `has_role(role_value)` now supports `Role` objects (comparison by `.key`) in addition to raw values.
-  - `CorePopulation.snapshot_period(period)` and `get_period_id_to_rownum(period)` for optional dynamic-population period indexing.
-
-#### Technical changes
-
-- Removed unused `openfisca_core.model_api` import in `tests/core/parameters_date_indexing/test_date_indexing.py`.
-- SimulationBuilder sets `_id_to_rownum` identity mapping for static simulations (`build_default_simulation`, `build_from_dict` / `build_from_entities`), for dynamic-population support.
-- Add `PYTHON` variable to `tasks/lint.mk` so `make lint PYTHON=.venv/bin/python` works; fix style in `test_link_accessors.py` and remove unused variable in `test_many2one.py`.
-
-## 44.3.0 [#1365](https://github.com/openfisca/openfisca-core/pull/1365)
-
-#### 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)`).
+## 44.6.0
 
 #### 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.5.0 → openfisca_core-44.7.0/OpenFisca_Core.egg-info}/PKG-INFO

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

{openfisca_core-44.5.0 → openfisca_core-44.7.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.5.0/OpenFisca_Core.egg-info → openfisca_core-44.7.0}/PKG-INFO

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

{openfisca_core-44.5.0 → openfisca_core-44.7.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.5.0 → openfisca_core-44.7.0}/openfisca_core/holders/holder.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any
 
-import bisect
 import os
 import warnings
 
@@ -30,10 +29,7 @@ class Holder:
         self.variable = variable
         self.simulation = population.simulation
         self._eternal = self.variable.definition_period == periods.DateUnit.ETERNITY
-        self._as_of = getattr(self.variable, "as_of", False)
         self._memory_storage = storage.InMemoryStorage(is_eternal=self._eternal)
-        if self._as_of:
-            self._sorted_instants: list = []
 
         # By default, do not activate on-disk storage, or variable dropping
         self._disk_storage = None
@@ -58,11 +54,6 @@ class Holder:
             if key not in ("population", "formula", "simulation"):
                 new_dict[key] = value
 
-        # _sorted_instants must be an independent copy so that writes to the
-        # clone don't corrupt the original's index.
-        if self._as_of:
-            new_dict["_sorted_instants"] = list(self._sorted_instants)
-
         new_dict["population"] = population
         new_dict["simulation"] = population.simulation
 
@@ -99,52 +90,10 @@ class Holder:
         value = self._memory_storage.get(period)
         if value is not None:
             return value
-        if self._as_of:
-            value = self._get_as_of(period)
-            if value is not None:
-                return value
         if self._disk_storage:
             return self._disk_storage.get(period)
         return None
 
-    def _get_as_of(self, period):
-        """Return the most recent stored value at or before the reference instant.
-
-        Uses a sorted list of instants + bisect for O(log P) lookup.
-        Falls back to a linear scan if _sorted_instants is not yet initialised
-        (e.g. after clone()).
-        """
-        target = period.start if self._as_of == "start" else period.stop
-        sorted_instants = getattr(self, "_sorted_instants", None)
-
-        if sorted_instants is not None:
-            pos = bisect.bisect_right(sorted_instants, target)
-            if pos == 0:
-                return None
-            best_instant = sorted_instants[pos - 1]
-        else:
-            # Fallback linear scan (e.g. after clone without _sorted_instants)
-            best_instant = None
-            for known_period in self._memory_storage.get_known_periods():
-                start = known_period.start
-                if start <= target:
-                    if best_instant is None or start > best_instant:
-                        best_instant = start
-            if best_instant is None:
-                return None
-
-        for known_period in self._memory_storage.get_known_periods():
-            if known_period.start == best_instant:
-                return self._memory_storage.get(known_period)
-        return None
-
-    def _register_instant(self, period) -> None:
-        """Insert period.start into the sorted instants list (no duplicates)."""
-        instant = period.start
-        pos = bisect.bisect_left(self._sorted_instants, instant)
-        if pos == len(self._sorted_instants) or self._sorted_instants[pos] != instant:
-            self._sorted_instants.insert(pos, instant)
-
     def get_memory_usage(self) -> t.MemoryUsage:
         """Get data about the virtual memory usage of the Holder.
 
@@ -353,25 +302,11 @@ class Holder:
             >= self.simulation.memory_config.max_memory_occupation_pc
         )
 
-        if self._as_of:
-            # Reference sharing: reuse existing array object when value unchanged,
-            # otherwise store a read-only defensive copy so that callers cannot
-            # corrupt stored data by mutating their original array in-place.
-            prev = self._get_as_of(period)
-            if prev is not None and numpy.array_equal(value, prev):
-                value = prev  # prev is already read-only
-            else:
-                value = value.copy()
-                value.flags.writeable = False
-
         if should_store_on_disk:
             self._disk_storage.put(value, period)
         else:
             self._memory_storage.put(value, period)
 
-        if self._as_of:
-            self._register_instant(period)
-
     def put_in_cache(self, value, period) -> None:
         if self._do_not_store:
             return

{openfisca_core-44.5.0 → openfisca_core-44.7.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.5.0 → openfisca_core-44.7.0}/openfisca_core/populations/_core_population.py

@@ -42,12 +42,6 @@ class CorePopulation:
 
     #: The :class:`~simulations.Simulation` for which the population is calculated.
     simulation: None | t.Simulation = None
-    # === Dynamic population helpers (optional) ===
-    _dynamic: bool = False
-    _permanent_ids: None | numpy.ndarray = None
-    _id_to_rownum: None | numpy.ndarray = None
-    _next_id: None | int = None
-    _period_index: None | dict = None
 
     def __init__(self, entity: t.CoreEntity, *__args: object, **__kwds: object) -> None:
         self.entity = entity
@@ -457,31 +451,5 @@ class CorePopulation:
             by_variable=holders_memory_usage,
         )
 
-    # -- Dynamic population period index helpers -------------------------
-
-    def snapshot_period(self, period: t.PeriodLike) -> None:
-        """Save the current ``_id_to_rownum`` mapping for ``period``.
-
-        If no ``_id_to_rownum`` exists yet, a default identity mapping is
-        created (positions == ids) sized to ``self.count``.
-        """
-        if self._period_index is None:
-            self._period_index = {}
-
-        if self._id_to_rownum is None:
-            # Default identity mapping: id -> row (0..count-1)
-            self._id_to_rownum = numpy.arange(self.count, dtype=numpy.intp)
-
-        self._period_index[periods.period(period)] = self._id_to_rownum.copy()
-
-    def get_period_id_to_rownum(self, period: t.PeriodLike) -> None | numpy.ndarray:
-        """Return the saved ``id -> rownum`` mapping for ``period`` or ``None``.
-
-        Returns ``None`` when no index was saved for that period.
-        """
-        if self._period_index is None:
-            return None
-        return self._period_index.get(periods.period(period))
-
 
 __all__ = ["CorePopulation"]

{openfisca_core-44.5.0 → openfisca_core-44.7.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.5.0 → openfisca_core-44.7.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.5.0 → openfisca_core-44.7.0}/openfisca_core/reforms/reform_excel.py

@@ -117,7 +117,10 @@ class ReformExcelTemplateGenerator:
                 for threshold, val in zip(value.thresholds, threshold_values):
                     values.append((f"{name}.{threshold}", val))
             else:
-                values.append((name, value))
+                if isinstance(value, list):
+                    values.append((name, ", ".join(value)))
+                else:
+                    values.append((name, value))
         return sorted(values, key=lambda v: v[0])
 
     def parameter_data(self) -> list[tuple[str, float]]:
@@ -212,7 +215,16 @@ class ReformExcel(Reform):
                         )
                     )
                 else:
-                    leaf.update(start=date_, value=value)
+                    if "unit" in leaf.metadata and leaf.metadata["unit"] == "list":
+                        if value is None:
+                            leaf.update(start=date_, value=[])
+                        else:
+                            values = [
+                                p.replace(",", "").strip() for p in value.split(" ")
+                            ]
+                            leaf.update(start=date_, value=[v for v in values if v])
+                    else:
+                        leaf.update(start=date_, value=value)
 
             for leaf, threshold in params_with_thresholds.values():
                 sorted_brackets = [v[1] for v in sorted(threshold, key=lambda x: x[0])]

{openfisca_core-44.5.0 → openfisca_core-44.7.0}/openfisca_core/simulations/_build_default_simulation.py

@@ -30,7 +30,6 @@ class _BuildDefaultSimulation:
         ...     .add_count()
         ...     .add_ids()
         ...     .add_members_entity_id()
-        ...     .add_id_to_rownum()
         ... )
 
         >>> builder.count
@@ -122,16 +121,6 @@ class _BuildDefaultSimulation:
 
         return self
 
-    def add_id_to_rownum(self) -> Self:
-        """Set identity id_to_rownum mapping on all populations.
-
-        For static simulations, each entity's permanent ID equals its row
-        position, so id_to_rownum is the identity: id_to_rownum[i] = i.
-        """
-        for population in self.populations.values():
-            population._id_to_rownum = numpy.arange(self.count, dtype=numpy.intp)
-        return self
-
     def add_members_entity_id(self) -> Self:
         """Add ???
 

{openfisca_core-44.5.0 → openfisca_core-44.7.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."""