objectstate 3.0.1__tar.gz → 3.0.3__tar.gz

{objectstate-3.0.1 → objectstate-3.0.3}/.github/badges/coverage.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="coverage: 75.78%"><title>coverage: 75.78%</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#67ac09"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">coverage</text><text x="315" y="150" fill-opacity=".3" textLength="510">coverage</text></g><text x="315" y="140" textLength="510">coverage</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">75.78%</text><text x="865" y="150" fill-opacity=".3" textLength="430">75.78%</text></g><text x="865" y="140" textLength="430">75.78%</text></g></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="coverage: 82.11%"><title>coverage: 82.11%</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#67ac09"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">coverage</text><text x="315" y="150" fill-opacity=".3" textLength="510">coverage</text></g><text x="315" y="140" textLength="510">coverage</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">82.11%</text><text x="865" y="150" fill-opacity=".3" textLength="430">82.11%</text></g><text x="865" y="140" textLength="430">82.11%</text></g></g></svg>

{objectstate-3.0.1 → objectstate-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: objectstate
-Version: 3.0.1
+Version: 3.0.3
 Summary: Generic lazy dataclass configuration framework with dual-axis inheritance and contextvars-based resolution
 Project-URL: Homepage, https://github.com/OpenHCSDev/objectstate
 Project-URL: Documentation, https://objectstate.readthedocs.io

{objectstate-3.0.1 → objectstate-3.0.3}/docs/state_propagation.rst

@@ -94,3 +94,42 @@ Use parent forwarding when all of the following are true:
 
 For a nested dataclass field in the same state, call ``update_parameter()`` on
 the dotted path instead.
+
+What a resolved value is computed from
+--------------------------------------
+
+A resolved value of a state is computed from three things: which states are
+registered at the scopes above it, what each of them stores for the field's config
+type and field name, and what the global config stores. Each resolved snapshot (live
+and saved) keeps the objects it was computed from (``ResolutionSources``): the global
+config instance of the thread that resolved it and the object of every state
+registered above. Every resolved read (``get_resolved_value``,
+``get_saved_resolved_value``, ``get_provenance``, ``to_resolved_object``,
+``state.fields``) first compares those objects with the ones the state would be given
+now. When they are the same objects the read answers from the snapshot. When one is
+another object, the two are compared field by field, the way field resolution reads a
+context layer, and only the fields of the state that are unset and can inherit a
+differing ``(config type, field)`` are resolved again. When other scopes have a
+registered state than before, every field is.
+
+So no caller announces a change. Registering, unregistering or replacing an ancestor,
+editing, saving, restoring, undoing or redoing an ancestor's value, and replacing the
+global config with ``set_live_global_config`` / ``set_saved_global_config`` all reach
+a state on its next read, whether the state is registered or not. A registered state
+is also told at once, so its subscribers hear of the change without a read; a state
+that is not registered is referenced by nothing and tells its subscribers on its next
+read.
+
+Limits:
+
+- Objects are compared by identity. A source that is changed in place is not seen.
+  ``ObjectState.to_object`` returns the same function object for a state that wraps a
+  plain function, so states registered below a function-backed state follow its edits
+  only through the registry (that is, when they are registered themselves).
+- The global config is stored per thread. A snapshot follows the global config of the
+  thread that resolved it; a read from another thread answers from the snapshot and
+  does not resolve it again for that thread's global config.
+- A state built or resolved inside a ``config_context`` the caller entered takes that
+  context's layers into its snapshot and keeps them after the block
+  (`issue #53 <https://github.com/OpenHCSDev/ObjectState/issues/53>`_).
+

{objectstate-3.0.1 → objectstate-3.0.3}/src/objectstate/__init__.py

@@ -210,7 +210,7 @@ __all__ = [
     'ObjectStateEditSession',
 ]
 
-__version__ = "3.0.1"
+__version__ = "3.0.3"
 __author__ = 'OpenHCS Team'
 __description__ = 'Generic configuration framework for lazy dataclass resolution'
 

{objectstate-3.0.1 → objectstate-3.0.3}/src/objectstate/docs/configuration_framework.rst

@@ -149,7 +149,7 @@ Usage Example
        )
    )
 
-The lazy configs resolve through dual-axis algorithm: check ``AppConfig`` context first, then ``GlobalAppConfig`` context, walking MRO at each level.
+The lazy configs resolve class first: ``DatabaseConfig`` is looked up in the ``AppConfig`` layer, then in the ``GlobalAppConfig`` layer, and only if neither holds a value is a base class of ``DatabaseConfig`` tried in those layers. A value on the more specific class in the global config therefore beats a value on a base class in the app config. :ref:`precedence-order` states the order with an example.
 
 Framework Modules
 ----------------

{objectstate-3.0.1 → objectstate-3.0.3}/src/objectstate/docs/context_system.rst

@@ -195,10 +195,37 @@ The dual-axis resolver reads the layer stack of the active context:
 
    value, source_scope, source_type = resolve_with_provenance(LazyDatabaseConfig, "port")
 
-For each type in the container type's MRO, most specific first, it asks every layer from
-innermost to outermost for a config of that type and returns the first value that is not
-``None``, together with the layer's scope id and the type it was read from. Attribute access
-on a lazy config returns the ``value`` of this same result.
+Attribute access on a lazy config returns the ``value`` of this same result.
+
+.. _precedence-order:
+
+Precedence Order
+~~~~~~~~~~~~~~~~
+
+Resolution is class first. For each class in the MRO of the type being read, most specific
+first, the resolver asks every layer from the innermost scope to the outermost for a config
+of that class and returns the first value that is not ``None``, together with the layer's
+scope id and the class it was read from. Only when no layer holds a value for a class is
+the next, less specific class tried.
+
+So the class decides before the scope does. Take ``Leaf(Base)``, a field ``value`` read on
+``Leaf`` in a step, and two layers that hold a value:
+
+==========================  ======================  =====================
+Layer (scope)               ``Base.value``          ``Leaf.value``
+==========================  ======================  =====================
+plate (inner)               ``"base at plate"``     ``None``
+global (outer)              ``None``                ``"leaf at global"``
+==========================  ======================  =====================
+
+The read returns ``"leaf at global"`` with source ``("", Leaf)``: ``Leaf`` is tried in
+every scope before ``Base`` is tried in any, although the plate is the nearer scope. A
+value on the same class in a nearer scope does win: with ``Leaf.value`` also set on the
+plate, the plate's value is returned.
+
+This is the only statement of the order. ``objectstate.dual_axis_resolver`` implements it
+in ``_resolve_in_layers``; ``tests/test_resolution_precedence_order.py`` checks it for
+every set of (class, scope) sites.
 
 Usage Pattern
 ------------

{objectstate-3.0.1 → objectstate-3.0.3}/src/objectstate/dual_axis_resolver.py

@@ -151,11 +151,16 @@ def resolve_in_stack(stack, container_type: type, field_name: str) -> ResolvedFi
 
 
 def _resolve_in_layers(layers: tuple, container_type: type, field_name: str) -> ResolvedField:
-    """Walk the container type's MRO and, for each type, the layers from inner to outer.
+    """Resolve class first: the MRO is the outer loop, the layers the inner one.
 
-    MRO order dominates layer order: ``None`` in an inner layer means "inherit", so
-    every outer layer is asked for the same type before a less specific type is
-    tried. A layer that masks the layers outside it ends the walk outward.
+    For each class in the container type's MRO, most specific first, every layer is
+    asked from the innermost scope to the outermost; the first value that is not
+    ``None`` wins. ``None`` in an inner layer means "inherit", so a less specific
+    class is tried only after every layer was asked for the more specific one.
+    A layer that masks the layers outside it ends the walk outward.
+
+    The order is stated with an example in ``docs/context_system.rst`` under
+    "Precedence Order"; this function is its implementation.
     """
     container_base = _normalize_to_base(container_type)
 

{objectstate-3.0.1 → objectstate-3.0.3}/src/objectstate/object_state.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import copy
 import logging
+import threading
 from collections.abc import Callable, Sequence
 from dataclasses import fields as dataclass_fields
 from dataclasses import is_dataclass
@@ -33,6 +34,7 @@ from objectstate.object_state_registry import ObjectStateRegistry
 from objectstate.scope_key import ScopeKey
 from objectstate.parameter_owner import ParameterOwner
 from objectstate.parameter_structure import ParameterStructure
+from objectstate.resolution_sources import ResolutionSources
 from objectstate.global_config import GlobalContextValues
 from objectstate.lazy_factory import is_global_config_type
 from objectstate.subfield_semantics import (
@@ -226,6 +228,10 @@ class ObjectState:
         # Maps dotted_path → (source_scope_id, source_type) for inherited fields
         # source_type may differ from local container_type due to MRO inheritance
         self._live_provenance: dict[str, tuple[str | None, type | None]] = {}
+        # What each resolved snapshot was computed from, keyed by ``use_saved``. A
+        # snapshot is current only while ``_resolution_sources()`` still returns the
+        # same objects; a snapshot without an entry is resolved again in full.
+        self._resolved_from: dict[bool, ResolutionSources] = {}
 
         # === Saved baseline (2 attributes) ===
         self._saved_resolved: dict[str, Any] = {}
@@ -264,9 +270,8 @@ class ObjectState:
         # === Time-Travel ===
         # Instance-level time-travel removed - use ObjectStateRegistry class-level DAG instead
 
-        # Initialize baselines (suppress flash during init)
-        self._ensure_live_resolved(notify_flash=False)
-        assert self._live_resolved is not None  # Guaranteed by _ensure_live_resolved
+        # Initialize baselines (nothing to tell anyone during init)
+        self._live_resolved = self._compute_resolved_snapshot()
 
         # CRITICAL: Initialize _saved_parameters BEFORE _compute_resolved_snapshot(use_saved=True)
         # because that method reads from _saved_parameters to get raw values.
@@ -476,8 +481,7 @@ class ObjectState:
     def to_saved_resolved_object(self) -> Any:
         """Reconstruct this state as an object with saved resolved values."""
         self._check_and_sync_delegate()
-        if not self._saved_resolved:
-            self._saved_resolved = self._compute_resolved_snapshot(use_saved=True)
+        self._ensure_saved_resolved()
         return self._reconstruct_from_resolved(
             "", self._saved_resolved, self._extraction_target, self._parameter_structure
         )
@@ -720,45 +724,167 @@ class ObjectState:
             self._forwarding_to_parent = False
 
     def _ensure_live_resolved(self, notify_flash: bool = True) -> set[str]:
-        """Ensure _live_resolved cache is populated.
-
-        PERFORMANCE: Field-level invalidation only.
-        - First access: full compute to populate cache
-        - After update_parameter(): only recompute invalid fields
-        - Cross-window access: return cached values directly (no work)
+        """Bring both resolved snapshots up to date; return the changed live paths.
+
+        Two things make a field out of date: it was invalidated on this state
+        (``_invalid_fields``), or the snapshot was computed from other sources than
+        the state has now (``_fields_with_other_sources``): an ancestor registered,
+        unregistered or replaced, an ancestor's value edited, saved or restored, the
+        global config replaced. Both are found here, on every resolved read, so no
+        caller has to announce a change and a state that is not registered follows
+        its ancestors like a registered one. Only the fields that can be affected are
+        resolved again; when nothing changed the cost is the comparison of the
+        sources.
 
         Args:
-            notify_flash: If True, fire on_resolved_changed callbacks for flash animations.
-                          Set to False during initialization to suppress flash.
-
-        Returns:
-            Set of paths that changed (for flash). Empty if no changes.
-
-        NOTE: This method handles CACHE + FLASH only. Caller handles _sync_materialized_state().
+            notify_flash: True (reads): when anything was resolved again, dirty and
+                signature fields are updated and subscribers are told here. False:
+                the caller does that with the returned paths
+                (``_sync_materialized_state``).
         """
-        # First access - populate cache
         if self._live_resolved is None:
+            # First access - populate cache; there is no earlier value to compare with.
             self._live_resolved = self._compute_resolved_snapshot()
             self._invalid_fields.clear()
-            return set()  # First populate - no "changes" to flash
+            return set()
+
+        sources, saved_sources = self._resolution_sources()
+        saved_resolved_again = self._resolve_saved_again_if_sources_changed(saved_sources)
+        if saved_resolved_again:
+            sources, _ = self._resolution_sources()
 
-        # Partial recompute for invalid fields only
-        if self._invalid_fields:
-            logger.debug(f"🔄 _ensure_live_resolved: scope={self.scope_id}, recomputing {len(self._invalid_fields)} invalid fields: {list(self._invalid_fields)}")
-            changed_paths = self._recompute_invalid_fields()
+        stale = self._fields_with_other_sources(sources, use_saved=False)
+        if stale is None:
+            # Other states are registered above this one: every inherited field may
+            # have another source. Pending field invalidations are covered.
+            previous = self._live_resolved
+            self._live_resolved = self._compute_resolved_snapshot()
             self._invalid_fields.clear()
+            changed_values = {
+                path: (previous.get(path), value)
+                for path, value in self._live_resolved.items()
+                if previous.get(path) != value
+            }
+            if changed_values:
+                self._set_last_changed_values(changed_values)
+            changed_paths = self.notification_fields_for_value_changes(changed_values)
+            live_resolved_again = True
         else:
-            logger.debug(f"🔄 _ensure_live_resolved: scope={self.scope_id}, no invalid fields to recompute")
-            changed_paths = set()
+            self._invalid_fields.update(stale)
+            live_resolved_again = bool(self._invalid_fields)
+            if live_resolved_again:
+                changed_paths = self._recompute_invalid_fields(sources)
+                self._invalid_fields.clear()
+            else:
+                changed_paths = set()
+            self._resolved_from[False] = sources.recorded_after(self._resolved_from.get(False))
 
-        if notify_flash and changed_paths:
-            self._notify_resolved_changed(
-                changed_paths,
-                context="_ensure_live_resolved",
-            )
+        if notify_flash and (live_resolved_again or saved_resolved_again):
+            self._sync_materialized_state(changed_value_fields=changed_paths)
 
         return changed_paths
 
+    def _resolution_sources(
+        self, *, sync_delegates: bool = False
+    ) -> tuple[ResolutionSources, ResolutionSources]:
+        """What this state's fields are resolved from today, live then saved (so the
+        pair is indexed by ``use_saved``): the global config stored for the running
+        thread and the objects of the other states registered above.
+
+        This state's own object is left out (its own parameters are not an outside
+        source), and so are global config objects of ancestors, for which
+        ``build_context_stack`` enters the global config itself.
+        """
+        from objectstate.config import get_base_config_type
+        from objectstate.global_config import get_live_global_config, get_saved_global_config
+
+        live: list[tuple[str, Any]] = []
+        saved: list[tuple[str, Any]] = []
+        for scope, state in ObjectStateRegistry.registered_ancestors(self.scope_id):
+            if state is self:
+                continue
+            saved_object = state.object_for_resolution(use_saved=True)
+            if is_global_config_type(type(saved_object)):
+                continue
+            saved.append((scope, saved_object))
+            live.append(
+                (scope, state.object_for_resolution(sync_delegate=sync_delegates))
+            )
+        thread = threading.current_thread()
+        global_config_type = get_base_config_type()
+        return (
+            ResolutionSources(thread, get_live_global_config(global_config_type), tuple(live)),
+            ResolutionSources(thread, get_saved_global_config(global_config_type), tuple(saved)),
+        )
+
+    def object_for_resolution(self, use_saved: bool = False, sync_delegate: bool = False) -> Any:
+        """The object a state below this one enters as a context layer.
+
+        Saved: the object as last saved, without delegate sync or reconstruction.
+        Live: rebuilt from the current parameters when they changed since the last
+        call; ``sync_delegate`` decides whether a replaced delegate is taken over
+        first, which must not happen while a snapshot is being recomputed.
+        """
+        if use_saved:
+            return self._extraction_target
+        if self._cached_object is not None and not sync_delegate:
+            return self._cached_object
+        return self.to_object(update_delegate=False, sync_delegate=sync_delegate)
+
+    def _fields_with_other_sources(
+        self, sources: ResolutionSources, *, use_saved: bool
+    ) -> set[str] | None:
+        """Fields of one snapshot that ``sources`` may resolve differently.
+
+        These are the fields this state leaves unset whose config type inherits a
+        ``(config type, field)`` that an ancestor or the global config stores
+        differently than when the snapshot was computed. A field this state sets
+        itself has no outside source. ``None`` means every field.
+        """
+        resolved_from = self._resolved_from.get(use_saved)
+        if sources.same_objects_as(resolved_from):
+            return set()
+        differing = sources.fields_that_differ(resolved_from)
+        if differing is None:
+            return None
+        own_values = self._saved_parameters if use_saved else self.parameters
+        return {
+            path
+            for config_type, field_name in differing
+            for path in self.inheritance_field_paths(config_type, field_name)
+            if own_values.get(path) is None
+        }
+
+    def _resolve_saved_again_if_sources_changed(self, sources: ResolutionSources) -> bool:
+        """Resolve the saved snapshot again when its sources changed; say whether it was.
+
+        The saved sources change when an ancestor is saved, restored or replaced and
+        when the saved global config is replaced, not while values are edited, so the
+        snapshot is resolved in full.
+        """
+        stale = self._fields_with_other_sources(sources, use_saved=True)
+        if stale is not None and not stale:
+            self._resolved_from[True] = sources.recorded_after(self._resolved_from.get(True))
+            return False
+        self._saved_resolved = self._compute_resolved_snapshot(use_saved=True)
+        return True
+
+    def resolve_again_if_sources_changed(self) -> None:
+        """Resolve again now, and tell subscribers, if this state's sources changed.
+
+        Every resolved read makes this check itself. ``ObjectStateRegistry`` calls it
+        when registration changes so subscribers are told at once.
+        """
+        if self._live_resolved is not None:
+            self._ensure_live_resolved()
+
+    def _ensure_saved_resolved(self) -> None:
+        """Make ``_saved_resolved`` hold every field, resolved from today's sources."""
+        if self._live_resolved is not None:
+            self._ensure_live_resolved()
+        elif not self._saved_resolved:
+            self._saved_resolved = self._compute_resolved_snapshot(use_saved=True)
+
     # DELETED: _create_nested_states() - No longer needed with flat storage
     # Nested ObjectStates are no longer created - flat storage handles all parameters
 
@@ -983,7 +1109,7 @@ class ObjectState:
         )
         # Establish the pre-mutation resolved authority even for a state that
         # has not yet been displayed. Raw edits can preserve the resolved value.
-        self._ensure_live_resolved(notify_flash=False)
+        changed_before_the_edit = self._ensure_live_resolved(notify_flash=False)
         ObjectStateRegistry.ensure_baseline_snapshot()
 
         # Update state directly (no type conversion - that's VIEW responsibility)
@@ -1051,7 +1177,7 @@ class ObjectState:
 
         # Materialize the origin once after its live context is authoritative,
         # then cascade only to descendants.
-        changed_paths = self._ensure_live_resolved(notify_flash=False)
+        changed_paths = self._ensure_live_resolved(notify_flash=False) | changed_before_the_edit
         for changed_param in changed_semantic_params:
             # SCOPE + TYPE + FIELD AWARE INVALIDATION:
             # Get the CONTAINER type for this field (e.g., PartitionFilterConfig for
@@ -1157,9 +1283,7 @@ class ObjectState:
         # Auto-detect delegate changes before resolving values
         self._check_and_sync_delegate()
 
-        # Ensure saved resolved cache is populated
-        if not self._saved_resolved:
-            self._saved_resolved = self._compute_resolved_snapshot(use_saved=True)
+        self._ensure_saved_resolved()
 
         # Check if this is a container/dataclass field (has subfields in _saved_resolved)
         prefix = f"{param_name}."
@@ -1190,8 +1314,7 @@ class ObjectState:
         self._check_and_sync_delegate()
         self._ensure_live_resolved()
         assert self._live_resolved is not None
-        if not self._saved_resolved:
-            self._saved_resolved = self._compute_resolved_snapshot(use_saved=True)
+        self._ensure_saved_resolved()
 
         path = owner_field_path
         raw_value = self.parameters.get(path.value, MISSING)
@@ -1730,8 +1853,8 @@ class ObjectState:
             f"Updated ObjectState(scope={self.scope_id!r}) to new instance of type {type(new_instance).__name__}"
         )
 
-    def _recompute_invalid_fields(self) -> set[str]:
-        """Recompute only the invalid fields, not the entire snapshot.
+    def _recompute_invalid_fields(self, sources: ResolutionSources) -> set[str]:
+        """Recompute only the invalid fields of the live snapshot, from ``sources``.
 
         PERFORMANCE: For explicitly set values, use parameters directly.
         Only build context stack for inherited (None) values.
@@ -1785,14 +1908,6 @@ class ObjectState:
             from objectstate.dual_axis_resolver import resolve_with_provenance
             from objectstate.lazy_factory import has_lazy_resolution
 
-            # Get ancestor objects for context stack building
-            # CRITICAL: Skip delegate sync to avoid re-entrant invalidate_cache() calls
-            # that would destroy _live_resolved while we're computing it.
-            ancestor_objects_with_scopes = ObjectStateRegistry.get_ancestor_objects_with_scopes(
-                self.scope_id,
-                skip_delegate_sync=True
-            )
-
             # ARCHITECTURAL FIX: Reconstruct current object from parameters for real-time MRO.
             # Using object_instance (original saved state) gives stale values, breaking inheritance.
             # Calling to_object() with sync_delegate=False reconstructs from CURRENT parameters
@@ -1801,7 +1916,7 @@ class ObjectState:
 
             with build_context_stack(
                 object_instance=current_obj,
-                ancestor_objects_with_scopes=ancestor_objects_with_scopes,
+                ancestor_objects_with_scopes=sources.ancestors,
                 current_scope_id=self.scope_id,
             ):
                 # For each inherited field, resolve using dual-axis resolution with provenance
@@ -2092,9 +2207,8 @@ class ObjectState:
             raise TypeError("ObjectState.parameters must remain a canonical flat dictionary.")
         if not isinstance(self._saved_parameters, dict):
             raise TypeError("ObjectState._saved_parameters must remain a canonical flat dictionary.")
-        ancestors = ObjectStateRegistry.get_ancestor_objects_with_scopes(
-            self.scope_id, use_saved=use_saved
-        )
+        sources = self._resolution_sources(sync_delegates=True)[use_saved]
+        self._resolved_from[use_saved] = sources
         current_obj = (
             self.saved_object if use_saved else self.to_object(update_delegate=False)
         )
@@ -2105,7 +2219,7 @@ class ObjectState:
             self._parameter_structure,
             current_obj,
             self.scope_id,
-            ancestors,
+            sources.ancestors,
             use_saved=use_saved,
         )
         if not use_saved: