All tests passing

Author: cffls

pycardano/serialization.py

@@ -10,7 +10,7 @@
 from datetime import datetime
 from decimal import Decimal
 from functools import wraps
-from inspect import isclass
+from inspect import getfullargspec, isclass
 from typing import (
     Any,
     Callable,
@@ -385,12 +385,15 @@ def to_validated_primitive(self) -> Primitive:
         return self.to_primitive()
 
     @classmethod
-    def from_primitive(cls: Type[CBORBase], value: Any) -> CBORBase:
+    def from_primitive(
+        cls: Type[CBORBase], value: Any, type_args: Optional[tuple] = None
+    ) -> CBORBase:
         """Turn a CBOR primitive to its original class type.
 
         Args:
             cls (CBORBase): The original class type.
             value (:const:`Primitive`): A CBOR primitive.
+            type_args (Optional[tuple]): Type arguments for the class.
 
         Returns:
             CBORBase: A CBOR serializable object.
@@ -543,7 +546,11 @@ def _restore_typed_primitive(
     if t is Any or (t in PRIMITIVE_TYPES and isinstance(v, t)):
         return v
     elif isclass(t) and issubclass(t, CBORSerializable):
-        return t.from_primitive(v)
+        if "type_args" in getfullargspec(t.from_primitive).args:
+            args = typing.get_args(t)
+            return t.from_primitive(v, type_args=args)
+        else:
+            return t.from_primitive(v)
     elif hasattr(t, "__origin__") and (t.__origin__ is list):
         t_args = t.__args__
         if len(t_args) != 1:
@@ -1001,28 +1008,41 @@ def to_shallow_primitive(self) -> Union[CBORTag, List[T]]:
         return list(self)
 
     @classmethod
-    def from_primitive(cls: Type[OrderedSet[T]], value: Any) -> OrderedSet[T]:
+    def from_primitive(
+        cls: OrderedSet[T], value: Any, type_args: Optional[tuple] = None
+    ) -> OrderedSet[T]:
+        assert (
+            type_args is None or len(type_args) == 1
+        ), "OrderedSet should have exactly one type argument"
+        # Retrieve the type arguments from the class
+        type_arg = type_args[0] if type_args else None
+
         if isinstance(value, CBORTag) and value.tag == 258:
+            if isclass(type_arg) and issubclass(type_arg, CBORSerializable):
+                value.value = [type_arg.from_primitive(v) for v in value.value]
             return cls(value.value, use_tag=True)
+
         if isinstance(value, (list, tuple, set)):
+            if isclass(type_arg) and issubclass(type_arg, CBORSerializable):
+                value = [type_arg.from_primitive(v) for v in value]
             return cls(list(value), use_tag=False)
+
         raise ValueError(f"Cannot deserialize {value} to {cls.__name__}")
 
 
 class NonEmptyOrderedSet(OrderedSet[T]):
     def __init__(self, iterable: Optional[List[T]] = None, use_tag: bool = True):
         super().__init__(iterable, use_tag)
 
-    def to_shallow_primitive(self) -> Union[CBORTag, List[T]]:
+    def validate(self):
         if not self:
             raise ValueError("NonEmptyOrderedSet cannot be empty")
-        return super().to_shallow_primitive()
 
     @classmethod
     def from_primitive(
-        cls: Type[NonEmptyOrderedSet[T]], value: Any
+        cls: NonEmptyOrderedSet[T], value: Any, type_args: Optional[tuple] = None
     ) -> NonEmptyOrderedSet[T]:
-        result = cast(NonEmptyOrderedSet[T], super().from_primitive(value))
+        result = cast(NonEmptyOrderedSet[T], super().from_primitive(value, type_args))
         if not result:
             raise ValueError("NonEmptyOrderedSet cannot be empty")
         return result

pycardano/transaction.py

@@ -518,7 +518,7 @@ class Withdrawals(DictCBORSerializable):
 
 @dataclass(repr=False)
 class TransactionBody(MapCBORSerializable):
-    inputs: OrderedSet[TransactionInput] = field(
+    inputs: Union[List[TransactionInput], OrderedSet[TransactionInput]] = field(
         default_factory=OrderedSet,
         metadata={"key": 0},
     )
@@ -562,15 +562,19 @@ class TransactionBody(MapCBORSerializable):
         default=None, metadata={"key": 11, "optional": True}
     )
 
-    collateral: Optional[Union[List[TransactionInput], NonEmptyOrderedSet[TransactionInput]]] = field(
+    collateral: Optional[
+        Union[List[TransactionInput], NonEmptyOrderedSet[TransactionInput]]
+    ] = field(
         default=None,
         metadata={
             "key": 13,
             "optional": True,
         },
     )
 
-    required_signers: Optional[Union[List[VerificationKeyHash], NonEmptyOrderedSet[VerificationKeyHash]]] = field(
+    required_signers: Optional[
+        Union[List[VerificationKeyHash], NonEmptyOrderedSet[VerificationKeyHash]]
+    ] = field(
         default=None,
         metadata={
             "key": 14,
@@ -590,7 +594,9 @@ class TransactionBody(MapCBORSerializable):
         default=None, metadata={"key": 17, "optional": True}
     )
 
-    reference_inputs: Optional[Union[List[TransactionInput], NonEmptyOrderedSet[TransactionInput]]] = field(
+    reference_inputs: Optional[
+        Union[List[TransactionInput], NonEmptyOrderedSet[TransactionInput]]
+    ] = field(
         default=None,
         metadata={
             "key": 18,

pycardano/witness.py

@@ -49,15 +49,19 @@ def from_primitive(
 
 @dataclass(repr=False)
 class TransactionWitnessSet(MapCBORSerializable):
-    vkey_witnesses: Optional[Union[List[VerificationKeyWitness], NonEmptyOrderedSet[VerificationKeyWitness]]] = field(
+    vkey_witnesses: Optional[
+        Union[List[VerificationKeyWitness], NonEmptyOrderedSet[VerificationKeyWitness]]
+    ] = field(
         default=None,
         metadata={
             "key": 0,
             "optional": True,
         },
     )
 
-    native_scripts: Optional[Union[List[NativeScript], NonEmptyOrderedSet[NativeScript]]] = field(
+    native_scripts: Optional[
+        Union[List[NativeScript], NonEmptyOrderedSet[NativeScript]]
+    ] = field(
         default=None,
         metadata={
             "key": 1,
@@ -70,7 +74,9 @@ class TransactionWitnessSet(MapCBORSerializable):
         default=None, metadata={"optional": True, "key": 2}
     )
 
-    plutus_v1_script: Optional[Union[List[PlutusV1Script], NonEmptyOrderedSet[PlutusV1Script]]] = field(
+    plutus_v1_script: Optional[
+        Union[List[PlutusV1Script], NonEmptyOrderedSet[PlutusV1Script]]
+    ] = field(
         default=None,
         metadata={
             "key": 3,
@@ -88,15 +94,19 @@ class TransactionWitnessSet(MapCBORSerializable):
         metadata={"optional": True, "key": 5},
     )
 
-    plutus_v2_script: Optional[Union[List[PlutusV2Script], NonEmptyOrderedSet[PlutusV2Script]]] = field(
+    plutus_v2_script: Optional[
+        Union[List[PlutusV2Script], NonEmptyOrderedSet[PlutusV2Script]]
+    ] = field(
         default=None,
         metadata={
             "key": 6,
             "optional": True,
         },
     )
 
-    plutus_v3_script: Optional[Union[List[PlutusV3Script], NonEmptyOrderedSet[PlutusV3Script]]] = field(
+    plutus_v3_script: Optional[
+        Union[List[PlutusV3Script], NonEmptyOrderedSet[PlutusV3Script]]
+    ] = field(
         default=None,
         metadata={
             "key": 7,

test/pycardano/test_serialization.py

@@ -1,13 +1,26 @@
 from collections import defaultdict, deque
 from dataclasses import dataclass, field
 from test.pycardano.util import check_two_way_cbor
-from typing import Any, Deque, Dict, List, Optional, Set, Tuple, Union
+from typing import (
+    Any,
+    Deque,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+)
 
 import cbor2
 import pytest
 from cbor2 import CBORTag
 
 from pycardano import (
+    CBORBase,
     Datum,
     MultiAsset,
     RawPlutusData,
@@ -605,17 +618,32 @@ def test_ordered_set_with_complex_types():
     )
     witness = VerificationKeyWitness(vkey, sig)
 
-    # Create OrderedSet[VerificationKeyWitness]
-    s = OrderedSet[VerificationKeyWitness]([witness])
-    assert len(s) == 1
-    assert witness in s
+    witness_set = TransactionWitnessSet(
+        vkey_witnesses=NonEmptyOrderedSet[VerificationKeyWitness]([witness])
+    )
+
+    # # Deserialize an OrderedSet[int]
+    # data = [1, 2, 3]
+    # ordered_set = OrderedSet[int].from_primitive(data)
+    # print(ordered_set)  # Output: OrderedSet([1, 2, 3])
+    #
+    # # Deserialize an OrderedSet[MyCBORClass]
+    # class MyCBORClass(ArrayCBORSerializable):
+    #     a: int
+    #
+    # @dataclass
+    # class MyCBORClass2(ArrayCBORSerializable):
+    #     a: OrderedSet[MyCBORClass]
+    #
+    #
+    # data = [{(1,), (2,)}]
+    # ordered_set = MyCBORClass2.from_primitive(data)
+    # print(ordered_set)  # Output: OrderedSet([MyCBORClass(), MyCBORClass()])
 
     # Test serialization/deserialization
-    primitive = s.to_primitive()
-    restored = OrderedSet[VerificationKeyWitness].from_primitive(primitive)
-    assert restored == s
-    assert restored[0].vkey == witness.vkey
-    assert restored[0].signature == witness.signature
+    primitive = witness_set.to_primitive()
+    restored = TransactionWitnessSet.from_primitive(primitive)
+    assert restored == witness_set
 
 
 def test_non_empty_ordered_set():
@@ -624,11 +652,11 @@ def test_non_empty_ordered_set():
     assert list(s) == [1, 2, 3]
 
     # Test validation of non-empty constraint
-    with pytest.raises(SerializeException, match="cannot be empty"):
+    with pytest.raises(ValueError, match="NonEmptyOrderedSet cannot be empty"):
         s = NonEmptyOrderedSet()
         s.to_validated_primitive()
 
-    with pytest.raises(SerializeException, match="cannot be empty"):
+    with pytest.raises(ValueError, match="NonEmptyOrderedSet cannot be empty"):
         s = NonEmptyOrderedSet([])
         s.to_validated_primitive()
 
@@ -674,14 +702,16 @@ def test_non_empty_ordered_set_with_complex_types():
 
     # Test serialization/deserialization
     primitive = s.to_primitive()
-    restored = NonEmptyOrderedSet[VerificationKeyWitness].from_primitive(primitive)
+    restored = NonEmptyOrderedSet[VerificationKeyWitness].from_primitive(
+        primitive, type_args=(VerificationKeyWitness,)
+    )
     assert restored == s
     assert restored[0].vkey == witness.vkey
     assert restored[0].signature == witness.signature
 
     # Test empty set validation
     s = NonEmptyOrderedSet[VerificationKeyWitness]()
-    with pytest.raises(SerializeException, match="cannot be empty"):
+    with pytest.raises(ValueError, match="NonEmptyOrderedSet cannot be empty"):
         s.to_validated_primitive()
 
 
@@ -710,7 +740,7 @@ def test_transaction_witness_set_with_ordered_sets():
 
     # Test empty list conversion
     witness_set = TransactionWitnessSet(vkey_witnesses=[])
-    with pytest.raises(SerializeException, match="cannot be empty"):
+    with pytest.raises(ValueError, match="NonEmptyOrderedSet cannot be empty"):
         witness_set.to_validated_primitive()
 
     # Test None value