Hacktoberfest 2026 : les issues que les mainteneurs ont marquées pour octobre, ouvertes et accessibles aux débutants. Parcourir les issues Hacktoberfest

Bug: resolve_references does not resolve references held in list fields

Ouverte Adaptée aux débutants
  • Quelque chose ne va pas ?
#43 0 commentaires 0 réactions 0 personnes assignées Voir sur GitHub

Personne n'a encore pris cette issue.

Évaluation

Difficulté
2/5
Temps estimé
1-3 heures
Accessibilité débutants
84/100
Type d'issue
Bug
Clarté
Clairement spécifiée
Activité
Active
Stack technique
python
Domaine
data

Piste de recherche

Commence dans rune/runtime/base_data_class.py, à resolve_references : l'étape de récursion gère déjà les champs de liste, tandis que l'étape de résolution des références ne vérifie que isinstance(obj, (UnresolvedReference, Reference)) sur la valeur de la propriété elle-même. Lance d'abord le test de reproduction autonome de l'issue pour confirmer l'échec, puis étends l'étape de résolution pour parcourir les éléments de liste et écrire les résultats par index, en contournant l'immutabilité de Pydantic comme le fait _bind_property_to pour les références scalaires. La tâche est terminée lorsque les deux assertions de la repro passent et que la suite de tests existante passe toujours.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

Bug Report

BaseDataClass.resolve_references only resolves references that are the direct value of a property. When a property holds a list, references within that list are silently skipped, leaving them as UnresolvedReference objects rather than the resolved instances.

Steps to Reproduce

  1. Define a Rune model with a type that has a multi-cardinality reference field (i.e., a field typed as a list of another type, decorated with @ref metadata):

    type Party:
    [metadata key]
    name string (1..1)

type Contract:
    parties Party (2..*)
        [metadata reference]

  2. Generate Python from the model. The parties field will be typed as a list with a reference validator:

    parties: Annotated[
    list[Party | BaseReference | None],
    Party.serializer(),
    Party.validator(('@key', '@key:external', '@ref', '@ref:external'))
] = Field(..., min_length=2)

  3. Deserialize a JSON document where the list field contains @ref entries:

    {
  "@type": "...",
  "party": [
    {"identifier": [{"id": {"@data": "p1"}}], "name": "Buyer"},
    {"identifier": [{"id": {"@data": "p2"}}], "name": "Seller"}
  ],
  "contract": {
    "@type": "...",
    "parties": [
      {"@ref": "p1"},
      {"@ref": "p2"}
    ]
  }
}

  4. Call BaseDataClass.rune_deserialize(json_str).

The following self-contained test reproduces the failure without a generator or CDM dependency:

from typing import Annotated, Optional
from pydantic import Field
from rune.runtime.base_data_class import BaseDataClass
from rune.runtime.metadata import BaseReference, UnresolvedReference

# --- minimal model ---

class Observation(BaseDataClass):
    value: str = Field(...)

class Reset(BaseDataClass):
    # single-cardinality reference — works correctly
    primaryObservation: Optional[Annotated[
        Observation,
        Observation.serializer(),
        Observation.validator(('@key', '@ref')),
    ]] = Field(None)

    # multi-cardinality reference — broken
    observations: Annotated[
        list[Observation | BaseReference | None],
        Observation.serializer(),
        Observation.validator(('@key', '@ref')),
    ] = Field(default_factory=list)

# --- JSON: one object defines @key, the other field references it via @ref ---

data = {
    'primaryObservation': {'@key': 'obs-1', 'value': '1.234'},
    'observations': [
        {'@ref': 'obs-1'},   # should resolve to the Observation above
    ],
}

model = Reset.rune_deserialize(data, validate_model=False)

# Scalar reference: resolved correctly
assert isinstance(model.primaryObservation, Observation), \
    f'Expected Observation, got {type(model.primaryObservation)}'

# List reference: NOT resolved — this assertion FAILS
assert isinstance(model.observations[0], Observation), \
    f'Expected Observation, got {type(model.observations[0])}'
# -> AssertionError: Expected Observation, got <class 'rune.runtime.metadata.UnresolvedReference'>
Expected Result

Reference resolution completes successfully. Each element of contract.parties is resolved to its corresponding Party instance — the same outcome as for a singular reference field.

Actual Result

The references in contract.parties are silently left as UnresolvedReference objects. No exception is raised during deserialization, but any attempt to use the field values fails at runtime because the elements are UnresolvedReference instances rather than Party instances.

Root cause: BaseDataClass.resolve_references (in base_data_class.py) iterates self.__dict__ and resolves properties whose value is directly an UnresolvedReference:

for prop_nm, obj in self.__dict__.items():
    if isinstance(obj, (UnresolvedReference, Reference)):   # <-- checks the property value
        refs.append((prop_nm, obj.get_reference(self)))

For a list field, obj is the list itself — not an UnresolvedReference — so the condition is False and none of the references inside the list are ever resolved.

The earlier loop in the same method already handles lists correctly for the recursion step (finding BaseDataClass children to recurse into), but the reference-resolution step does not apply the same pattern.

Environment
  • rune-python-runtime current main
  • Observed during ingestion of CDM production samples
Additional Context

The fix requires iterating list elements in the resolution step, analogous to the existing recursion step:

for prop_nm, obj in self.__dict__.items():
    if isinstance(obj, (UnresolvedReference, Reference)):
        refs.append((prop_nm, obj.get_reference(self)))
    elif isinstance(obj, (MutableSequence, tuple)):
        for i, item in enumerate(obj):
            if isinstance(item, (UnresolvedReference, Reference)):
                list_refs.append((prop_nm, i, item.get_reference(self)))

Resolved items must then be written back into the list by index, and the binding must bypass Pydantic's immutability the same way the scalar case does via _bind_property_to.

Langage dominant
Python
Étoiles
0
Forks
4
Merge moyen
1 j 11 h
PR mergées (30 j)
3

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de finos/rune-python-runtime

Toutes les issues de finos/rune-python-runtime

Issues similaires

Plus d'issues Python

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.