fixed subcondition instantiation recursively (#328)

* fixed subcondition instantiation recursively
* blackified
* updated changelog

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>

---------

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>

CHANGELOG.md

@@ -26,6 +26,7 @@ For reference, the possible headings are:
 * **Notes**
 
 ## [2.2.4] - 2023-15-02
+* **Fixed** subcondition instantiation now works recursively
 * **Changed** migrated dependency management to poetry
 * **Removed** removed unused text_search related code
 * **Changed** docs are now built using poetry

planetmint/backend/models/output.py

@@ -8,57 +8,32 @@ from dataclasses import dataclass, field
 from typing import List
 
 
-@dataclass
-class SubCondition:
-    type: str
-    public_key: str
-
-    def to_tuple(self) -> tuple:
-        return self.type, self.public_key
-
-    def to_dict(self) -> dict:
-        return {"type": self.type, "public_key": self.public_key}
-
-    @staticmethod
-    def from_dict(subcondition_dict: dict) -> SubCondition:
-        return SubCondition(subcondition_dict["type"], subcondition_dict["public_key"])
-
-    @staticmethod
-    def list_to_dict(subconditions: List[SubCondition]) -> List[dict] | None:
-        if subconditions is None:
-            return None
-        return [subcondition.to_dict() for subcondition in subconditions]
-
-
 @dataclass
 class ConditionDetails:
     type: str = ""
     public_key: str = ""
     threshold: int = None
-    sub_conditions: list[SubCondition] = None
+    sub_conditions: List[ConditionDetails] = field(default_factory=list)
 
     def to_dict(self) -> dict:
         if self.sub_conditions is None:
-            return {
+            return {"type": self.type, "public_key": self.public_key}
-                "type": self.type,
-                "public_key": self.public_key,
-            }
         else:
             return {
                 "type": self.type,
                 "threshold": self.threshold,
-                "subconditions": [subcondition.to_dict() for subcondition in self.sub_conditions],
+                "subconditions": [sub_condition.to_dict() for sub_condition in self.sub_conditions],
             }
 
     @staticmethod
-    def from_dict(data: dict) -> ConditionDetails:
+    def from_dict(details: dict) -> ConditionDetails:
         sub_conditions = None
-        if "subconditions" in data:
+        if "subconditions" in details:
-            sub_conditions = [SubCondition.from_dict(sub_condition) for sub_condition in data["subconditions"]]
+            sub_conditions = [ConditionDetails.from_dict(sub_condition) for sub_condition in details["subconditions"]]
         return ConditionDetails(
-            type=data.get("type"),
+            type=details.get("type"),
-            public_key=data.get("public_key"),
+            public_key=details.get("public_key"),
-            threshold=data.get("threshold"),
+            threshold=details.get("threshold"),
             sub_conditions=sub_conditions,
         )
 
@@ -126,17 +101,9 @@ class Output:
 
     def to_dict(self) -> dict:
         return {
-            "id": self.id,
+            # "id": self.id,
             "public_keys": self.public_keys,
-            "condition": {
+            "condition": self.condition.to_dict(),
-                "details": {
-                    "type": self.condition.details.type,
-                    "public_key": self.condition.details.public_key,
-                    "threshold": self.condition.details.threshold,
-                    "subconditions": SubCondition.list_to_dict(self.condition.details.sub_conditions),
-                },
-                "uri": self.condition.uri,
-            },
             "amount": str(self.amount),
         }
 
@@ -151,11 +118,7 @@ def output_with_public_key(output, transaction_id) -> Output:
         public_keys=output["public_keys"],
         amount=output["amount"],
         condition=Condition(
-            uri=output["condition"]["uri"],
+            uri=output["condition"]["uri"], details=ConditionDetails.from_dict(output["condition"]["details"])
-            details=ConditionDetails(
-                type=output["condition"]["details"]["type"],
-                public_key=output["condition"]["details"]["public_key"],
-            ),
         ),
     )
 
@@ -166,17 +129,6 @@ def output_with_sub_conditions(output, transaction_id) -> Output:
         public_keys=output["public_keys"],
         amount=output["amount"],
         condition=Condition(
-            uri=output["condition"]["uri"],
+            uri=output["condition"]["uri"], details=ConditionDetails.from_dict(output["condition"]["details"])
-            details=ConditionDetails(
-                type=output["condition"]["details"]["type"],
-                threshold=output["condition"]["details"]["threshold"],
-                sub_conditions=[
-                    SubCondition(
-                        type=sub_condition["type"],
-                        public_key=sub_condition["public_key"],
-                    )
-                    for sub_condition in output["condition"]["details"]["subconditions"]
-                ],
-            ),
         ),
     )

tests/backend/test_models.py

@@ -0,0 +1,40 @@
+# Copyright © 2020 Interplanetary Database Association e.V.,
+# Planetmint and IPDB software contributors.
+# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
+# Code is Apache-2.0 and docs are CC-BY-4.0
+
+from planetmint.backend.models import Output
+
+nested_threshold_output = {
+    "amount": "1",
+    "condition": {
+        "details": {
+            "subconditions": [
+                {"type": "ed25519-sha-256", "public_key": "7pT7eBEGJsmpUvRFhu7NUQSZVJVZDeF1xREuYKdVYUKK"},
+                {
+                    "subconditions": [
+                        {"type": "ed25519-sha-256", "public_key": "746ZbyMgoCJykAdzZ2vZcHzwnndrVnAAh6pv6yLZDiH2"},
+                        {"type": "ed25519-sha-256", "public_key": "EYb188vCQoaYDmW3Agen1u6Fh7xvDWCMnWJK8ueuCdbX"},
+                    ],
+                    "threshold": 2,
+                    "type": "threshold-sha-256",
+                },
+            ],
+            "threshold": 1,
+            "type": "threshold-sha-256",
+        },
+        "uri": "ni:///sha-256;hhw6Rf9JgwKYkapwE9qu7oVaI0ArS0hj_dmzAkpIPdc?fpt=threshold-sha-256&cost=266240&subtypes=ed25519-sha-256",
+    },
+    "public_keys": [
+        "7pT7eBEGJsmpUvRFhu7NUQSZVJVZDeF1xREuYKdVYUKK",
+        "746ZbyMgoCJykAdzZ2vZcHzwnndrVnAAh6pv6yLZDiH2",
+        "EYb188vCQoaYDmW3Agen1u6Fh7xvDWCMnWJK8ueuCdbX",
+    ],
+}
+
+
+def test_output_nested_threshold_condition():
+    output = Output.outputs_dict(nested_threshold_output)
+    assert output
+    output_dict = output.to_dict()
+    assert nested_threshold_output == output_dict