fix(clients): keep Python instance references out of numeric values

InstanceRef is no longer an int subclass, so Vector, Quantity, Array and TensorQuantity dimensions and typed.as_int/as_float/as_complex refuse it instead of encoding it as int_value; Connection still sends it as instance_id.

Co-Authored-By: jason.han <hanhuijun@gmail.com>

Author: devin-ai-integration[bot]

clients/python/opensysml/connection.py

@@ -1722,7 +1722,7 @@ def _python_to_value(self, py_value):
         if isinstance(py_value, bool):
             return sysml_pb2.Value(bool_value=py_value)
         elif isinstance(py_value, InstanceRef):
-            return sysml_pb2.Value(instance_id=int(py_value))
+            return sysml_pb2.Value(instance_id=py_value.id)
         elif isinstance(py_value, int):
             return sysml_pb2.Value(int_value=py_value)
         elif isinstance(py_value, float):

clients/python/opensysml/values.py

@@ -781,31 +781,31 @@ def same_value(a: Any, b: Any) -> bool:
     """Whether two decoded values are the same value, as :class:`SetValue` membership judges it.
 
     ``==`` decides, except that a ``bool`` is never a number — ``True`` and ``1``
-    are distinct values in a model — and an :class:`InstanceRef` is never an
-    Integer, in a nested ``list`` or :class:`Array` too.
+    are distinct values in a model — in a nested ``list`` or :class:`Array` too.
     """
     if isinstance(a, bool) or isinstance(b, bool):
         return isinstance(a, bool) and isinstance(b, bool) and a == b
-    if isinstance(a, InstanceRef) or isinstance(b, InstanceRef):
-        return isinstance(a, InstanceRef) and isinstance(b, InstanceRef) and a == b
     if isinstance(a, list) and isinstance(b, list):
         return len(a) == len(b) and all(same_value(x, y) for x, y in zip(a, b))
     return a == b
 
 
-class InstanceRef(int):
+@dataclass(frozen=True)
+class InstanceRef:
     """A reference to an instance the client has no instance graph to resolve.
 
-    It is the instance's integer id, so it reads and compares as one where an
-    ``int`` is expected; but it is not the Integer of that value in a model, so
-    :func:`same_value` keeps the two apart, and sent back it is again an
-    instance reference.
+    It holds the instance's id and is nothing else: not the Integer of that
+    value, so it is never equal to one nor accepted where a number is, and sent
+    back it is again an instance reference.
+
+    Attributes:
+        id (int): The instance's id
     """
 
-    __slots__ = ()
+    id: int
 
-    def __repr__(self) -> str:
-        return f"InstanceRef({int(self)})"
+    def __str__(self) -> str:
+        return f"instance({self.id})"
 
 
 @dataclass(frozen=True)
@@ -941,7 +941,7 @@ def value_to_python(pb_value, resolve_instance=None):
         pb_value: sysml_pb2.Value message
         resolve_instance: optional callable mapping an instance id to an object;
             when omitted, instance references are returned as an
-            :class:`InstanceRef`, an ``int`` holding the id.
+            :class:`InstanceRef` holding the id.
 
     Returns:
         int, float, complex, bool, str, list, None, :data:`UNSET`, a

clients/python/tests/test_instance.py

@@ -3,6 +3,7 @@
 from opensysml.errors import FeatureValueError
 from opensysml.proto import sysml_pb2
 from opensysml.instance import Instance
+from opensysml.values import InstanceRef
 
 
 def scalar_feature(name, **value_kwargs):
@@ -156,16 +157,17 @@ def test_nested_instance_resolution():
     assert inst.engine is engine
 
 
-def test_unresolvable_instance_id_falls_back_to_id():
-    """Without the child in the graph, the bare id is returned."""
+def test_unresolvable_instance_id_falls_back_to_a_reference():
+    """Without the child in the graph, a reference holding the id is returned."""
     pb_inst = sysml_pb2.Instance(
         id=1,
         type_symbol_id="Test::P",
         feature_values={"engine": scalar_feature("engine", instance_id=42)},
     )
 
     inst = Instance(pb_inst)
-    assert inst.engine == 42
+    assert inst.engine == InstanceRef(42)
+    assert inst.engine != 42
 
 
 def test_error_slot_raises_slot_error():

clients/python/tests/test_set_tensor.py

@@ -21,9 +21,10 @@
     CAPABILITY_VERIFICATION,
     MissingCapabilityError,
 )
+from opensysml import typed
 from opensysml.connection import Connection
 from opensysml.enumeration import EnumLiteral
-from opensysml.errors import ExecutionError, UnsupportedValueError
+from opensysml.errors import ExecutionError, TypeMismatchError, UnsupportedValueError
 from opensysml.proto import sysml_pb2
 from opensysml.values import (
     Array,
@@ -34,6 +35,7 @@
     TensorQuantity,
     Unit,
     UnitFactor,
+    Vector,
     VectorQuantity,
     value_to_python,
 )
@@ -315,9 +317,10 @@ def test_members_that_only_look_alike_are_distinct(elements, expected):
     assert 1 not in SetValue((True,)) and True not in SetValue((1,))
 
 
-def test_an_unresolved_instance_reference_is_its_id_but_not_an_integer():
+def test_an_unresolved_instance_reference_holds_its_id_but_is_not_an_integer():
     ref = value_to_python(pb_instance(7))
-    assert isinstance(ref, InstanceRef) and ref == 7 and repr(ref) == "InstanceRef(7)"
+    assert isinstance(ref, InstanceRef) and ref.id == 7 and ref == InstanceRef(7)
+    assert ref != 7 and not isinstance(ref, int) and str(ref) == "instance(7)"
     assert ref in SetValue((InstanceRef(7),)) and ref not in SetValue((7,))
     assert Array((1,), (ref,)) != Array((1,), (7,))
     assert Array((2,), (True, 1)) != Array((2,), (1, 1))
@@ -327,6 +330,25 @@ def test_an_unresolved_instance_reference_is_its_id_but_not_an_integer():
     sent = conn._python_to_value(SetValue((ref, 7)))
     assert [e.WhichOneof("kind") for e in sent.set.elements] == ["instance_id", "int_value"]
     assert sent.set.elements[0].instance_id == 7
+    assert value_to_python(sent) == SetValue((InstanceRef(7), 7))
+
+
+def test_an_instance_reference_is_refused_where_a_number_is_meant():
+    ref = InstanceRef(7)
+    with pytest.raises(ValueError, match="not a number"):
+        Vector((1, ref))
+    with pytest.raises(ValueError, match="not a positive integer"):
+        Array((ref,), (1,))
+    with pytest.raises(ValueError, match="not a positive integer"):
+        TensorQuantity((ref,), [Quantity(1.0, PASCAL)])
+    with pytest.raises(TypeError):
+        Quantity(1.0, PASCAL) * ref
+    with pytest.raises(TypeMismatchError):
+        typed.as_int("n", ref)
+    with pytest.raises(TypeMismatchError):
+        typed.as_float("x", ref)
+    with pytest.raises(TypeMismatchError):
+        typed.as_complex("z", ref)
 
 
 def test_a_set_survives_the_wire_bytes():

clients/python/tests/test_unset.py

@@ -9,7 +9,7 @@
 from opensysml.errors import FeatureValueError
 from opensysml.instance import Instance
 from opensysml.proto import sysml_pb2
-from opensysml.values import UNSET, UnsetType, feature_value_to_python, value_to_python
+from opensysml.values import UNSET, InstanceRef, UnsetType, feature_value_to_python, value_to_python
 
 import pytest
 
@@ -57,7 +57,7 @@ def test_a_valued_slot_and_an_object_valued_one_are_unaffected():
     object_valued = sysml_pb2.FeatureValue(
         feature_name="engine", value=sysml_pb2.Value(instance_id=7), materialized=True
     )
-    assert feature_value_to_python("engine", object_valued) == 7
+    assert feature_value_to_python("engine", object_valued) == InstanceRef(7)
 
 
 def test_an_unmaterialized_slot_is_still_an_error():