rune-runtime 2.2.0__tar.gz → 2.2.1__tar.gz

{rune_runtime-2.2.0/src/rune_runtime.egg-info → rune_runtime-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rune-runtime
-Version: 2.2.0
+Version: 2.2.1
 Summary: rune-runtime: the Rune DSL runtime for Python
 Author: Daniel Schwartz, Plamen Neykov, Others (See AUTHORS)
 License-Expression: Apache-2.0

{rune_runtime-2.2.0 → rune_runtime-2.2.1}/src/rune/runtime/base_data_class.py

@@ -125,6 +125,15 @@ class BaseDataClass(BaseModel, ComplexTypeMetaDataMixin):
                 return aux
         obj = handler(data)
         obj._init_rune_parent()  # pylint: disable=protected-access
+        if isinstance(data, dict):
+            # Deferred annotations can bypass the field metadata validator.
+            # Retain target keys before resolving references to this model.
+            keys = {k: v for k, v in metadata.items() if k.startswith('@key')}
+            if keys:
+                # Field-level validators handle allowed metadata, including
+                # scoped keys that are not declared on the target class.
+                obj.set_meta(check_allowed=False, **keys)
+                obj._register_keys(keys)  # pylint: disable=protected-access
         obj.resolve_references(ignore_dangling=True, recurse=False)
         # transfer refs that were established on the original before 
         # re-validation wiped them
@@ -140,9 +149,12 @@ class BaseDataClass(BaseModel, ComplexTypeMetaDataMixin):
             self.__dict__[RUNE_OBJ_MAPS] = {}
 
         for prop_nm, obj in self.__dict__.items():
-            if (isinstance(obj, BaseMetaDataMixin)
-                    and not prop_nm.startswith('__') and prop_nm not in refs):
-                obj._set_rune_parent(self)  # pylint: disable=protected-access
+            if prop_nm.startswith('__') or prop_nm in refs:
+                continue
+            children = obj if isinstance(obj, (MutableSequence, tuple)) else (obj,)
+            for child in children:
+                if isinstance(child, BaseMetaDataMixin):
+                    child._set_rune_parent(self)  # pylint: disable=protected-access
 
     def rune_serialize(
         self,
@@ -306,11 +318,17 @@ class BaseDataClass(BaseModel, ComplexTypeMetaDataMixin):
     def resolve_references(self, ignore_dangling=False, recurse=True):
         '''resolves all attributes which are references'''
         if recurse:
+            resolved_refs = self._get_rune_refs_container()
             for prop_nm, obj in self.__dict__.items():
-                if (isinstance(obj, BaseDataClass)
-                        and not prop_nm.startswith('__')):
-                    obj.resolve_references(ignore_dangling=ignore_dangling,
-                                           recurse=recurse)
+                # Follow containment only; resolved references can point back
+                # to an ancestor and must not be traversed again.
+                if prop_nm.startswith('__') or prop_nm in resolved_refs:
+                    continue
+                children = obj if isinstance(obj, (MutableSequence, tuple)) else (obj,)
+                for child in children:
+                    if isinstance(child, BaseDataClass):
+                        child.resolve_references(ignore_dangling=ignore_dangling,
+                                                 recurse=recurse)
 
         refs = []
         for prop_nm, obj in self.__dict__.items():

{rune_runtime-2.2.0 → rune_runtime-2.2.1}/src/rune/runtime/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.2.1'
+__version_tuple__ = version_tuple = (2, 2, 1)
 
-__commit_id__ = commit_id = 'g58791175d'
+__commit_id__ = commit_id = 'g05cabe482'

{rune_runtime-2.2.0 → rune_runtime-2.2.1/src/rune_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rune-runtime
-Version: 2.2.0
+Version: 2.2.1
 Summary: rune-runtime: the Rune DSL runtime for Python
 Author: Daniel Schwartz, Plamen Neykov, Others (See AUTHORS)
 License-Expression: Apache-2.0

{rune_runtime-2.2.0 → rune_runtime-2.2.1}/src/rune_runtime.egg-info/SOURCES.txt

@@ -75,6 +75,7 @@ test/functions/specs/cdm/_bundle.py
 test/functions/specs/cdm/base/math/Abs.py
 test/functions/specs/cdm/base/math/RoundToNearest.py
 test/functions/specs/cdm/base/math/RoundingModeEnum.py
+test/local_data/ird-ex01-vanilla-swap-versioned.json
 test/serializer-round-trip/test_basic.py
 test/serializer-round-trip/test_conditions.py
 test/serializer-round-trip/test_enumtype.py

{rune_runtime-2.2.0 → rune_runtime-2.2.1}/src/rune_runtime.egg-info/scm_file_list.json

@@ -50,6 +50,7 @@
     "test/functions/specs/cdm/base/math/RoundingModeEnum.py",
     "test/functions/specs/test_native_registry.py",
     "test/functions/specs/test_simple.py",
+    "test/local_data/ird-ex01-vanilla-swap-versioned.json",
     "test/run_runtime_tests.sh",
     "test/serializer-round-trip/test_basic.py",
     "test/serializer-round-trip/test_conditions.py",

rune_runtime-2.2.1/src/rune_runtime.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.2.1",
+  "distance": 0,
+  "node": "g05cabe4820d4659485de75d071c296b38c2e4d45",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-16"
+}

rune_runtime-2.2.1/test/cdm/test_validation.py

@@ -0,0 +1,46 @@
+'''Full attribute validation - pydantic and constraints'''
+from pathlib import Path
+import pytest
+from pydantic import ValidationError
+from rune.runtime.base_data_class import BaseDataClass
+try:
+    # pylint: disable=unused-import
+    # type: ignore
+    from cdm.base.math.NonNegativeQuantity import NonNegativeQuantity
+    from cdm.base.math.UnitType import UnitType
+    NO_SER_TEST_MOD = False
+except ImportError:
+    NO_SER_TEST_MOD = True
+
+
+@pytest.mark.skipif(NO_SER_TEST_MOD, reason='CDM package not found')
+def test_bad_attrib_validation():
+    '''Invalid attribute assigned'''
+    unit = UnitType(currency='EUR')
+    mq = NonNegativeQuantity(value=10, unit=unit)
+    mq.frequency = 'Blah'
+    with pytest.raises(ValidationError):
+        mq.validate_model()
+
+
+def test_vanilla_swap_list_reference_validation():
+    '''Validate the reported sample when local data and the CDM bundle exist.'''
+    sample = Path(__file__).resolve().parents[1] / 'local_data' / 'ird-ex01-vanilla-swap-versioned.json'
+    if not sample.is_file():
+        pytest.skip('Local CDM sample not found')
+    pytest.importorskip('finos')
+
+    model = BaseDataClass.rune_deserialize(
+        sample.read_text(encoding='utf-8'),
+        namespace_prefix='finos',
+        check_rune_constraints=False,
+    )
+
+    assert len(model.trade.counterparty) == 2
+    parties = {party.get_meta('@key:external'): party for party in model.trade.party}
+    for counterparty in model.trade.counterparty:
+        key = counterparty.resolve_ref_key('partyReference')
+        assert counterparty.partyReference is parties[key]
+    assert model.validate_model(check_rune_constraints=False) == []
+
+# EOF

rune_runtime-2.2.1/test/local_data/ird-ex01-vanilla-swap-versioned.json

@@ -0,0 +1,307 @@
+{
+  "@model" : "cdm",
+  "@type" : "cdm.event.common.TradeState",
+  "@version" : "0.0.0.master-SNAPSHOT",
+  "@key" : "3afe24c4",
+  "trade" : {
+    "product" : {
+      "taxonomy" : [ {
+        "source" : "ISDA",
+        "value" : {
+          "name" : {
+            "@data" : "InterestRate_IRSwap_FixedFloat"
+          }
+        },
+        "calculated" : true
+      } ],
+      "economicTerms" : {
+        "payout" : [ {
+          "@type" : "cdm.product.asset.InterestRatePayout",
+          "payerReceiver" : {
+            "payer" : "Party1",
+            "receiver" : "Party2"
+          },
+          "priceQuantity" : {
+            "quantitySchedule" : {
+              "@ref:scoped" : "quantity-1"
+            }
+          },
+          "rateSpecification" : {
+            "@type" : "cdm.product.asset.FloatingRateSpecification",
+            "rateOption" : {
+              "@ref:scoped" : "InterestRateIndex-1"
+            }
+          },
+          "dayCountFraction" : {
+            "@data" : "ACT/360"
+          },
+          "calculationPeriodDates" : {
+            "@key:external" : "floatingCalcPeriodDates",
+            "effectiveDate" : {
+              "adjustableDate" : {
+                "unadjustedDate" : "1994-12-14",
+                "dateAdjustments" : {
+                  "businessDayConvention" : "NONE"
+                }
+              }
+            },
+            "terminationDate" : {
+              "adjustableDate" : {
+                "unadjustedDate" : "1999-12-14",
+                "dateAdjustments" : {
+                  "businessDayConvention" : "MODFOLLOWING"
+                }
+              }
+            },
+            "calculationPeriodDatesAdjustments" : {
+              "businessDayConvention" : "MODFOLLOWING",
+              "businessCenters" : {
+                "businessCentersReference" : {
+                  "@ref:external" : "primaryBusinessCenters"
+                }
+              }
+            },
+            "calculationPeriodFrequency" : {
+              "periodMultiplier" : 6,
+              "period" : "M",
+              "rollConvention" : "14"
+            }
+          },
+          "paymentDates" : {
+            "paymentFrequency" : {
+              "periodMultiplier" : 6,
+              "period" : "M"
+            },
+            "payRelativeTo" : "CalculationPeriodEndDate",
+            "paymentDatesAdjustments" : {
+              "businessDayConvention" : "MODFOLLOWING",
+              "businessCenters" : {
+                "businessCentersReference" : {
+                  "@ref:external" : "primaryBusinessCenters"
+                }
+              }
+            }
+          },
+          "resetDates" : {
+            "@key:external" : "resetDates",
+            "calculationPeriodDatesReference" : {
+              "@ref:external" : "floatingCalcPeriodDates"
+            },
+            "resetRelativeTo" : "CalculationPeriodStartDate",
+            "fixingDates" : {
+              "periodMultiplier" : -2,
+              "period" : "D",
+              "dayType" : "Business",
+              "businessDayConvention" : "NONE",
+              "dateRelativeTo" : {
+                "@ref" : "a0134250",
+                "@ref:external" : "resetDates"
+              }
+            },
+            "resetFrequency" : {
+              "periodMultiplier" : 6,
+              "period" : "M"
+            },
+            "resetDatesAdjustments" : {
+              "businessDayConvention" : "MODFOLLOWING",
+              "businessCenters" : {
+                "businessCentersReference" : {
+                  "@ref:external" : "primaryBusinessCenters"
+                }
+              }
+            }
+          }
+        }, {
+          "@type" : "cdm.product.asset.InterestRatePayout",
+          "payerReceiver" : {
+            "payer" : "Party2",
+            "receiver" : "Party1"
+          },
+          "priceQuantity" : {
+            "quantitySchedule" : {
+              "@ref:scoped" : "quantity-2"
+            }
+          },
+          "rateSpecification" : {
+            "@type" : "cdm.product.asset.FixedRateSpecification",
+            "rateSchedule" : {
+              "price" : {
+                "@ref:scoped" : "price-1"
+              }
+            }
+          },
+          "dayCountFraction" : {
+            "@data" : "30E/360"
+          },
+          "calculationPeriodDates" : {
+            "@key:external" : "fixedCalcPeriodDates",
+            "effectiveDate" : {
+              "adjustableDate" : {
+                "unadjustedDate" : "1994-12-14",
+                "dateAdjustments" : {
+                  "businessDayConvention" : "NONE"
+                }
+              }
+            },
+            "terminationDate" : {
+              "adjustableDate" : {
+                "unadjustedDate" : "1999-12-14",
+                "dateAdjustments" : {
+                  "businessDayConvention" : "MODFOLLOWING",
+                  "businessCenters" : {
+                    "businessCentersReference" : {
+                      "@ref:external" : "primaryBusinessCenters"
+                    }
+                  }
+                }
+              }
+            },
+            "calculationPeriodDatesAdjustments" : {
+              "businessDayConvention" : "MODFOLLOWING",
+              "businessCenters" : {
+                "businessCentersReference" : {
+                  "@ref:external" : "primaryBusinessCenters"
+                }
+              }
+            },
+            "calculationPeriodFrequency" : {
+              "periodMultiplier" : 1,
+              "period" : "Y",
+              "rollConvention" : "14"
+            }
+          },
+          "paymentDates" : {
+            "paymentFrequency" : {
+              "periodMultiplier" : 1,
+              "period" : "Y"
+            },
+            "payRelativeTo" : "CalculationPeriodEndDate",
+            "paymentDatesAdjustments" : {
+              "businessDayConvention" : "MODFOLLOWING",
+              "businessCenters" : {
+                "businessCentersReference" : {
+                  "@ref:external" : "primaryBusinessCenters"
+                }
+              }
+            }
+          }
+        } ]
+      }
+    },
+    "tradeLot" : [ {
+      "priceQuantity" : [ {
+        "quantity" : {
+          "@key:scoped" : "quantity-1",
+          "value" : 50000000.00,
+          "unit" : {
+            "currency" : {
+              "@scheme" : "http://www.fpml.org/coding-scheme/external/iso4217",
+              "@data" : "EUR"
+            }
+          }
+        },
+        "observable" : {
+          "@key:scoped" : "observable-1",
+          "@data" : {
+            "@type" : "cdm.observable.asset.InterestRateIndex",
+            "@key:scoped" : "InterestRateIndex-1",
+            "@data" : {
+              "@type" : "cdm.observable.asset.FloatingRateIndex",
+              "identifier" : [ {
+                "identifier" : {
+                  "@data" : "EUR-LIBOR-BBA"
+                },
+                "identifierType" : "Other"
+              } ],
+              "assetType" : "Other",
+              "assetClass" : "InterestRate",
+              "floatingRateIndex" : {
+                "@data" : "EUR-LIBOR-BBA"
+              },
+              "indexTenor" : {
+                "periodMultiplier" : 6,
+                "period" : "M"
+              }
+            }
+          }
+        }
+      }, {
+        "price" : [ {
+          "@key:scoped" : "price-1",
+          "value" : 0.06,
+          "unit" : {
+            "currency" : {
+              "@scheme" : "http://www.fpml.org/coding-scheme/external/iso4217",
+              "@data" : "EUR"
+            }
+          },
+          "perUnitOf" : {
+            "currency" : {
+              "@scheme" : "http://www.fpml.org/coding-scheme/external/iso4217",
+              "@data" : "EUR"
+            }
+          },
+          "priceType" : "InterestRate"
+        } ],
+        "quantity" : {
+          "@key:scoped" : "quantity-2",
+          "value" : 50000000.00,
+          "unit" : {
+            "currency" : {
+              "@scheme" : "http://www.fpml.org/coding-scheme/external/iso4217",
+              "@data" : "EUR"
+            }
+          }
+        }
+      } ]
+    } ],
+    "counterparty" : [ {
+      "role" : "Party1",
+      "partyReference" : {
+        "@ref:external" : "party1"
+      }
+    }, {
+      "role" : "Party2",
+      "partyReference" : {
+        "@ref:external" : "party2"
+      }
+    } ],
+    "tradeIdentifier" : [ {
+      "issuerReference" : {
+        "@ref:external" : "party2"
+      },
+      "assignedIdentifier" : [ {
+        "identifier" : {
+          "@scheme" : "http://www.barclays.com/swaps/trade-id",
+          "@data" : "SW2000"
+        },
+        "version" : 1
+      } ]
+    } ],
+    "tradeDate" : {
+      "@data" : "1994-12-12"
+    },
+    "party" : [ {
+      "@key:external" : "party1",
+      "partyId" : [ {
+        "identifier" : {
+          "@scheme" : "http://www.fpml.org/coding-scheme/external/iso9362",
+          "@data" : "PARTYAUS33"
+        },
+        "identifierType" : "BIC"
+      } ],
+      "name" : {
+        "@data" : "Party A"
+      }
+    }, {
+      "@key:external" : "party2",
+      "partyId" : [ {
+        "identifier" : {
+          "@scheme" : "http://www.fpml.org/coding-scheme/external/iso9362",
+          "@data" : "BARCGB2L"
+        },
+        "identifierType" : "BIC"
+      } ]
+    } ]
+  }
+}

rune_runtime-2.2.1/test/test_deep_keys_and_references.py

@@ -0,0 +1,247 @@
+'''test module for ref lifecycle'''
+from collections import UserList
+from typing import Optional, Annotated
+from pydantic import Field
+import pytest
+from rune.runtime.metadata import Reference, KeyType, UnresolvedReference
+from rune.runtime.base_data_class import BaseDataClass
+
+
+class B(BaseDataClass):
+    '''no doc'''
+    fieldB: str = Field(..., description='')
+
+
+class A(BaseDataClass):
+    '''no doc'''
+    b: Annotated[B, B.serializer(),
+                 B.validator(('@key:scoped', ))] = Field(..., description='')
+
+
+class Root(BaseDataClass):
+    '''no doc'''
+    typeA: Optional[Annotated[A, A.serializer(),
+                              A.validator()]] = Field(None, description='')
+    bAddress: Optional[Annotated[B,
+                                 B.serializer(),
+                                 B.validator(('@ref:scoped', ))]] = Field(
+                                     None, description='')
+    _KEY_REF_CONSTRAINTS = {
+        'bAddress': {'@ref:scoped'}
+    }
+
+class DeepRef(BaseDataClass):
+    '''no doc'''
+    root: Annotated[Root, Root.serializer(),
+                    Root.validator()] = Field(..., description='')
+
+
+class ListedReferences(BaseDataClass):
+    '''References and their targets occur in separate list fields.'''
+    references: list[Annotated[Root, Root.validator()]]
+    targets: list[Annotated[A, A.validator()]]
+
+
+class NestedListedReferences(BaseDataClass):
+    '''Exercise lists below both model fields and other lists.'''
+    groups: list[Annotated[ListedReferences, ListedReferences.validator()]]
+    labels: list[str] = Field(default_factory=list)
+
+
+class SequenceContainer(BaseDataClass):
+    '''Keep sequence implementations intact during validation.'''
+    entries: object
+
+
+class CyclicReference(BaseDataClass):
+    '''A resolved reference can point back to its containing object.'''
+    _ALLOWED_METADATA = {'@key'}
+    target: Annotated[BaseDataClass, BaseDataClass.validator(('@ref', ))]
+    _KEY_REF_CONSTRAINTS = {'target': {'@ref'}}
+
+
+@pytest.fixture
+def listed_reference_data():
+    '''A forward reference to a target in a sibling list.'''
+    return {
+        'groups': [{
+            'references': [
+                {'bAddress': {'@ref:scoped': 'first'}},
+                {'bAddress': {'@ref:scoped': 'second'}},
+            ],
+            'targets': [
+                {'b': {'@key:scoped': 'first', 'fieldB': 'first target'}},
+                {'b': {'@key:scoped': 'second', 'fieldB': 'second target'}},
+            ],
+        }],
+        'labels': ['primitive list entries are ignored'],
+    }
+
+
+def test_list_children_share_parent_and_key_maps(listed_reference_data):
+    '''Keys from list children must be visible to sibling list entries.'''
+    model = NestedListedReferences.model_validate(listed_reference_data)
+    group = model.groups[0]
+
+    assert group.get_rune_parent() is model
+    for reference, target in zip(group.references, group.targets):
+        assert reference.get_rune_parent() is group
+        assert target.get_rune_parent() is group
+        key = target.b.get_meta('@key:scoped')
+        assert reference.get_object_by_key(key, KeyType.SCOPED) is target.b
+
+
+def test_deserialize_and_validate_references_in_nested_lists(listed_reference_data):
+    '''Rune deserialization resolves every list entry before validation.'''
+    model = NestedListedReferences.rune_deserialize(listed_reference_data)
+    group = model.groups[0]
+
+    for reference, target in zip(group.references, group.targets):
+        assert reference.bAddress is target.b
+        assert reference.resolve_ref_key('bAddress') == target.b.get_meta('@key:scoped')
+    assert model.validate_model() == []
+
+    model.resolve_references()
+    for reference, target in zip(group.references, group.targets):
+        assert reference.bAddress is target.b
+
+
+def test_resolve_list_references_respects_recurse_false(listed_reference_data):
+    '''Nonrecursive resolution leaves child references untouched.'''
+    model = NestedListedReferences.model_validate(listed_reference_data)
+
+    model.resolve_references(recurse=False)
+
+    assert all(isinstance(ref.bAddress, UnresolvedReference)
+               for ref in model.groups[0].references)
+
+
+def test_resolve_list_references_respects_ignore_dangling(listed_reference_data):
+    '''Missing list references may be ignored or reported by the caller.'''
+    listed_reference_data['groups'][0]['references'][1]['bAddress'] = {
+        '@ref:scoped': 'missing-key'
+    }
+    model = NestedListedReferences.model_validate(listed_reference_data)
+
+    model.resolve_references(ignore_dangling=True)
+
+    group = model.groups[0]
+    assert group.references[0].bAddress is group.targets[0].b
+    assert isinstance(group.references[1].bAddress, UnresolvedReference)
+    with pytest.raises(KeyError, match='missing-key'):
+        model.resolve_references(ignore_dangling=False)
+
+
+@pytest.mark.parametrize('sequence_type', [list, tuple, UserList])
+def test_resolve_references_in_sequence_types(sequence_type):
+    '''Supported sequences provide both parent wiring and reference traversal.'''
+    reference = Root.model_validate({'bAddress': {'@ref:scoped': 'target'}})
+    target = A.model_validate({'b': {'@key:scoped': 'target', 'fieldB': 'value'}})
+    model = SequenceContainer(entries=sequence_type([reference, target, 'label', None]))
+
+    model.resolve_references()
+
+    assert reference.get_rune_parent() is model
+    assert target.get_rune_parent() is model
+    assert reference.bAddress is target.b
+
+
+def test_resolve_references_skips_resolved_cycles_in_lists():
+    '''Repeated resolution must not recurse through an already-bound reference.'''
+    child = CyclicReference.model_validate({'target': {'@ref': 'self'}})
+    child.target = Reference(child)
+    model = SequenceContainer(entries=[child])
+
+    model.resolve_references()
+    model.resolve_references()
+
+    assert child.target is child
+
+
+def test_ref_creation():
+    '''no doc'''
+    b = B(fieldB='some b content')
+    a = A(b=b)
+    root = Root(typeA=a, bAddress=Reference(a.b, 'aKey', KeyType.SCOPED))
+    # pylint: disable=no-member
+    assert id(root.typeA.b) == id(root.bAddress)
+
+
+def test_deep_ref_creation():
+    '''no doc'''
+    b = B(fieldB='some b content')
+    a = A(b=b)
+    root = Root(typeA=a, bAddress=Reference(a.b, 'aKey2', KeyType.SCOPED))
+    deep_ref = DeepRef(root=root)
+    # pylint: disable=no-member
+    assert id(deep_ref.root.typeA.b) == id(deep_ref.root.bAddress)
+
+
+def test_fail_wrong_key_ext():
+    '''no doc'''
+    b = B(fieldB='some b content')
+    a = A(b=b)
+    with pytest.raises(ValueError):
+        Root(typeA=a, bAddress=Reference(a.b, 'aKey', KeyType.EXTERNAL))
+
+
+def test_fail_wrong_key_int():
+    '''no doc'''
+    b = B(fieldB='some b content')
+    a = A(b=b)
+    with pytest.raises(ValueError):
+        Root(typeA=a, bAddress=Reference(a.b))
+
+
+def test_scoped_reference_metadata_and_type():
+    '''scoped refs should store key type and metadata'''
+    b = B(fieldB='some b content')
+    a = A(b=b)
+    root = Root(typeA=a, bAddress=Reference(a.b, 'aKeyScoped', KeyType.SCOPED))
+    assert b.get_meta('@key:scoped') == 'aKeyScoped'
+    assert root.__dict__['__rune_references']['bAddress'][1] == KeyType.SCOPED
+
+
+def test_ref_prefers_scoped_over_internal():
+    '''scoped ref should be preferred when both tags are provided'''
+    rune_dict = {
+        "bAddress": {
+            "@ref": "internalKey",
+            "@ref:scoped": "scopedKey"
+        },
+        "typeA": {
+            "b": {
+                "@key:scoped": "scopedKey",
+                "fieldB": "some b content"
+            }
+        },
+    }
+    root = Root.model_validate(rune_dict)
+    assert root.bAddress == root.typeA.b
+    assert root.__dict__['__rune_references']['bAddress'][1] == KeyType.SCOPED
+
+
+def test_invalid_multiple_ref_tags_raise():
+    '''unknown multiple ref tags should raise'''
+    rune_dict = {
+        "bAddress": {
+            "@ref:foo": "key1",
+            "@ref:bar": "key2"
+        }
+    }
+    with pytest.raises(ValueError):
+        Root.model_validate(rune_dict)
+
+
+def test_scoped_key_not_visible_outside_scope(mocker):
+    '''scoped keys should not leak across scope instances'''
+    mocker.patch('rune.runtime.metadata.BaseMetaDataMixin._DEFAULT_SCOPE_TYPE',
+                 'test_deep_keys_and_references.Root')
+    b = B(fieldB='some b content')
+    a = A(b=b)
+    Root(typeA=a, bAddress=Reference(a.b, 'aKeyScoped', KeyType.SCOPED))
+    root2 = Root.model_validate({"bAddress": {"@ref:scoped": "aKeyScoped"}})
+    with pytest.raises(KeyError):
+        root2.resolve_references(ignore_dangling=False, recurse=False)
+
+# EOF

{rune_runtime-2.2.0 → rune_runtime-2.2.1}/test/test_deferred_ref_deserialization.py

@@ -16,6 +16,8 @@ because its required fields are absent.
 
 The fix is to have _deserialize_refs check for reference dicts BEFORE calling
 handler, consistent with ComplexTypeMetaDataMixin.deserialize.
+Target keys must also be retained when the deferred schema bypasses the field
+metadata validator, so references in sibling lists can find their targets.
 
 Note on placement: this test lives in rune-runtime even though the Phase 1/2/3
 pattern originates in the rune-python-generator's bundle generator.  The runtime
@@ -29,7 +31,7 @@ import pytest
 from pydantic import Field
 
 from rune.runtime.base_data_class import BaseDataClass
-from rune.runtime.metadata import BaseReference, UnresolvedReference
+from rune.runtime.metadata import BaseReference, KeyType, UnresolvedReference
 
 
 class Issuer(BaseDataClass):
@@ -45,7 +47,7 @@ class Contract(BaseDataClass):
     name: str = Field(..., description='Contract name')
 
     _KEY_REF_CONSTRAINTS = {
-        'issuerReference': {'@key', '@key:external', '@ref', '@ref:external'}
+        'issuerReference': {'@key', '@key:external', '@ref', '@ref:external', '@ref:scoped'}
     }
 
 
@@ -55,7 +57,7 @@ def _apply_deferred_annotations():
     Contract.__annotations__['issuerReference'] = Annotated[
         Optional[Issuer | BaseReference],
         Issuer.serializer(),
-        Issuer.validator(('@key', '@key:external', '@ref', '@ref:external')),
+        Issuer.validator(('@key', '@key:external', '@ref', '@ref:external', '@ref:scoped')),
     ]
     Contract.model_rebuild(force=True)
 
@@ -63,6 +65,31 @@ def _apply_deferred_annotations():
 _apply_deferred_annotations()
 
 
+class Portfolio(BaseDataClass):
+    '''Bare field types reproduce schemas rebuilt from deferred annotations.'''
+    contracts: list[Contract]
+    issuers: list[Issuer]
+
+
+@pytest.mark.parametrize('key_type', list(KeyType))
+def test_deferred_list_targets_retain_keys_and_resolve(key_type):
+    '''Target keys must survive even when field metadata validators are absent.'''
+    data = {
+        'contracts': [{
+            'name': 'test-contract',
+            'issuerReference': {key_type.rune_ref_tag: 'party1'},
+        }],
+        'issuers': [{key_type.rune_key_tag: 'party1', 'partyId': ['LEI-001']}],
+    }
+
+    portfolio = Portfolio.rune_deserialize(data)
+
+    assert portfolio.issuers[0].get_meta(key_type.key_tag) == 'party1'
+    assert portfolio.contracts[0].issuerReference is portfolio.issuers[0]
+    assert portfolio.get_object_by_key('party1', key_type) is portfolio.issuers[0]
+    assert portfolio.validate_model() == []
+
+
 def test_ref_external_deserializes_to_unresolved_reference():
     '''A ref dict in a deferred field should produce an UnresolvedReference,
     not a validation error about missing required fields on the target type.'''

rune_runtime-2.2.0/src/rune_runtime.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "2.2.0",
-  "distance": 0,
-  "node": "g58791175d98fff845230d3c6657d620ccb15f2d2",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-10"
-}

rune_runtime-2.2.0/test/cdm/test_validation.py

@@ -1,23 +0,0 @@
-'''Full attribute validation - pydantic and constraints'''
-import pytest
-from pydantic import ValidationError
-try:
-    # pylint: disable=unused-import
-    # type: ignore
-    from cdm.base.math.NonNegativeQuantity import NonNegativeQuantity
-    from cdm.base.math.UnitType import UnitType
-    NO_SER_TEST_MOD = False
-except ImportError:
-    NO_SER_TEST_MOD = True
-
-
-@pytest.mark.skipif(NO_SER_TEST_MOD, reason='CDM package not found')
-def test_bad_attrib_validation():
-    '''Invalid attribute assigned'''
-    unit = UnitType(currency='EUR')
-    mq = NonNegativeQuantity(value=10, unit=unit)
-    mq.frequency = 'Blah'
-    with pytest.raises(ValidationError):
-        mq.validate_model()
-
-# EOF

rune_runtime-2.2.0/test/test_deep_keys_and_references.py

@@ -1,124 +0,0 @@
-'''test module for ref lifecycle'''
-from typing import Optional, Annotated
-from pydantic import Field
-import pytest
-from rune.runtime.metadata import Reference, KeyType
-from rune.runtime.base_data_class import BaseDataClass
-
-
-class B(BaseDataClass):
-    '''no doc'''
-    fieldB: str = Field(..., description='')
-
-
-class A(BaseDataClass):
-    '''no doc'''
-    b: Annotated[B, B.serializer(),
-                 B.validator(('@key:scoped', ))] = Field(..., description='')
-
-
-class Root(BaseDataClass):
-    '''no doc'''
-    typeA: Optional[Annotated[A, A.serializer(),
-                              A.validator()]] = Field(None, description='')
-    bAddress: Optional[Annotated[B,
-                                 B.serializer(),
-                                 B.validator(('@ref:scoped', ))]] = Field(
-                                     None, description='')
-    _KEY_REF_CONSTRAINTS = {
-        'bAddress': {'@ref:scoped'}
-    }
-
-class DeepRef(BaseDataClass):
-    '''no doc'''
-    root: Annotated[Root, Root.serializer(),
-                    Root.validator()] = Field(..., description='')
-
-
-def test_ref_creation():
-    '''no doc'''
-    b = B(fieldB='some b content')
-    a = A(b=b)
-    root = Root(typeA=a, bAddress=Reference(a.b, 'aKey', KeyType.SCOPED))
-    # pylint: disable=no-member
-    assert id(root.typeA.b) == id(root.bAddress)
-
-
-def test_deep_ref_creation():
-    '''no doc'''
-    b = B(fieldB='some b content')
-    a = A(b=b)
-    root = Root(typeA=a, bAddress=Reference(a.b, 'aKey2', KeyType.SCOPED))
-    deep_ref = DeepRef(root=root)
-    # pylint: disable=no-member
-    assert id(deep_ref.root.typeA.b) == id(deep_ref.root.bAddress)
-
-
-def test_fail_wrong_key_ext():
-    '''no doc'''
-    b = B(fieldB='some b content')
-    a = A(b=b)
-    with pytest.raises(ValueError):
-        Root(typeA=a, bAddress=Reference(a.b, 'aKey', KeyType.EXTERNAL))
-
-
-def test_fail_wrong_key_int():
-    '''no doc'''
-    b = B(fieldB='some b content')
-    a = A(b=b)
-    with pytest.raises(ValueError):
-        Root(typeA=a, bAddress=Reference(a.b))
-
-
-def test_scoped_reference_metadata_and_type():
-    '''scoped refs should store key type and metadata'''
-    b = B(fieldB='some b content')
-    a = A(b=b)
-    root = Root(typeA=a, bAddress=Reference(a.b, 'aKeyScoped', KeyType.SCOPED))
-    assert b.get_meta('@key:scoped') == 'aKeyScoped'
-    assert root.__dict__['__rune_references']['bAddress'][1] == KeyType.SCOPED
-
-
-def test_ref_prefers_scoped_over_internal():
-    '''scoped ref should be preferred when both tags are provided'''
-    rune_dict = {
-        "bAddress": {
-            "@ref": "internalKey",
-            "@ref:scoped": "scopedKey"
-        },
-        "typeA": {
-            "b": {
-                "@key:scoped": "scopedKey",
-                "fieldB": "some b content"
-            }
-        },
-    }
-    root = Root.model_validate(rune_dict)
-    assert root.bAddress == root.typeA.b
-    assert root.__dict__['__rune_references']['bAddress'][1] == KeyType.SCOPED
-
-
-def test_invalid_multiple_ref_tags_raise():
-    '''unknown multiple ref tags should raise'''
-    rune_dict = {
-        "bAddress": {
-            "@ref:foo": "key1",
-            "@ref:bar": "key2"
-        }
-    }
-    with pytest.raises(ValueError):
-        Root.model_validate(rune_dict)
-
-
-def test_scoped_key_not_visible_outside_scope(mocker):
-    '''scoped keys should not leak across scope instances'''
-    mocker.patch('rune.runtime.metadata.BaseMetaDataMixin._DEFAULT_SCOPE_TYPE',
-                 'test_deep_keys_and_references.Root')
-    b = B(fieldB='some b content')
-    a = A(b=b)
-    Root(typeA=a, bAddress=Reference(a.b, 'aKeyScoped', KeyType.SCOPED))
-    root2 = Root.model_validate({"bAddress": {"@ref:scoped": "aKeyScoped"}})
-    with pytest.raises(KeyError):
-        root2.resolve_references(ignore_dangling=False, recurse=False)
-
-# EOF