Okay a complete rework

Author: Quexington

chia/util/streamable.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import dataclasses
+import functools
 import io
 import os
 import pprint
@@ -210,39 +211,33 @@ def streamable_from_dict(klass: type[_T_Streamable], item: Any) -> _T_Streamable
 
 
 def function_to_convert_one_item(
-    f_type: type[Any], json_parsers: Optional[list[Callable[[object], Streamable]]] = None
+    f_type: type[Any], json_parser: Optional[Callable[[object, type[object]], Streamable]] = None
 ) -> ConvertFunctionType:
     if is_type_SpecificOptional(f_type):
-        convert_inner_func = function_to_convert_one_item(get_args(f_type)[0], json_parsers)
+        convert_inner_func = function_to_convert_one_item(get_args(f_type)[0], json_parser)
         return lambda item: convert_optional(convert_inner_func, item)
     elif is_type_Tuple(f_type):
         args = get_args(f_type)
         convert_inner_tuple_funcs = []
         for arg in args:
-            convert_inner_tuple_funcs.append(function_to_convert_one_item(arg, json_parsers))
+            convert_inner_tuple_funcs.append(function_to_convert_one_item(arg, json_parser))
         # Ignoring for now as the proper solution isn't obvious
         return lambda items: convert_tuple(convert_inner_tuple_funcs, items)  # type: ignore[arg-type]
     elif is_type_List(f_type):
         inner_type = get_args(f_type)[0]
-        convert_inner_func = function_to_convert_one_item(inner_type, json_parsers)
+        convert_inner_func = function_to_convert_one_item(inner_type, json_parser)
         # Ignoring for now as the proper solution isn't obvious
         return lambda items: convert_list(convert_inner_func, items)  # type: ignore[arg-type]
     elif is_type_Dict(f_type):
         inner_types = get_args(f_type)
-        if json_parsers is None:
-            key_parsers = None
-            value_parsers = None
-        else:
-            key_parsers = [json_parsers[0]]
-            value_parsers = [json_parsers[1]]
-        key_converter = function_to_convert_one_item(inner_types[0], key_parsers)
-        value_converter = function_to_convert_one_item(inner_types[1], value_parsers)
+        key_converter = function_to_convert_one_item(inner_types[0], json_parser)
+        value_converter = function_to_convert_one_item(inner_types[1], json_parser)
         return lambda mapping: convert_dict(key_converter, value_converter, mapping)  # type: ignore[arg-type]
     elif hasattr(f_type, "from_json_dict"):
-        if json_parsers is None:
+        if json_parser is None:
             return f_type.from_json_dict  # type: ignore[no-any-return]
         else:
-            return json_parsers[0]
+            return functools.partial(json_parser, streamable_type=f_type)  # type: ignore[call-arg]
     elif issubclass(f_type, bytes):
         # Type is bytes, data is a hex string or bytes
         return lambda item: convert_byte_type(f_type, item)

chia/wallet/util/clvm_streamable.py

@@ -3,7 +3,7 @@
 import dataclasses
 import functools
 from types import MappingProxyType
-from typing import Any, Callable, Generic, Optional, TypeVar, Union, get_args, get_type_hints
+from typing import Any, Callable, Generic, Optional, TypeVar, Union, get_type_hints
 
 from hsms.clvm_serde import from_program_for_type, to_program_for_type
 from typing_extensions import TypeGuard
@@ -116,64 +116,38 @@ def json_deserialize_with_clvm_streamable(
     streamable_type: type[_T_Streamable],
     translation_layer: Optional[TranslationLayer] = None,
 ) -> _T_Streamable:
+    # This function is flawed for compound types because it's highjacking the function_to_convert_one_item func
+    # which does not call back to it. More examination is needed.
     if isinstance(json_dict, str):
         return byte_deserialize_clvm_streamable(
             bytes.fromhex(json_dict), streamable_type, translation_layer=translation_layer
         )
-    elif not hasattr(streamable_type, "streamable_fields"):
-        if is_compound_type(streamable_type):
-            inner_types = get_args(streamable_type)
-            return function_to_convert_one_item(  # type: ignore[return-value]
-                streamable_type,
-                [
-                    functools.partial(
-                        json_deserialize_with_clvm_streamable,
-                        streamable_type=inner_type,
-                        translation_layer=translation_layer,
-                    )
-                    for inner_type in inner_types
-                ],
-            )(json_dict)
-        else:
-            return function_to_convert_one_item(streamable_type)(json_dict)  # type: ignore[return-value]
-    else:
+    elif hasattr(streamable_type, "streamable_fields"):
         old_streamable_fields = streamable_type.streamable_fields()
         new_streamable_fields = []
         for old_field in old_streamable_fields:
-            if is_compound_type(old_field.type):
-                inner_types = get_args(old_field.type)
-                new_streamable_fields.append(
-                    dataclasses.replace(
-                        old_field,
-                        convert_function=function_to_convert_one_item(
-                            old_field.type,
-                            [
-                                functools.partial(
-                                    json_deserialize_with_clvm_streamable,
-                                    streamable_type=inner_type,
-                                    translation_layer=translation_layer,
-                                )
-                                for inner_type in inner_types
-                            ],
-                        ),
-                    )
-                )
-            elif is_clvm_streamable_type(old_field.type):
-                new_streamable_fields.append(
-                    dataclasses.replace(
-                        old_field,
-                        convert_function=functools.partial(
+            new_streamable_fields.append(
+                dataclasses.replace(
+                    old_field,
+                    convert_function=function_to_convert_one_item(
+                        old_field.type,
+                        functools.partial(
                             json_deserialize_with_clvm_streamable,
-                            streamable_type=old_field.type,
                             translation_layer=translation_layer,
                         ),
-                    )
+                    ),
                 )
-            else:
-                new_streamable_fields.append(old_field)
-
+            )
         setattr(streamable_type, "_streamable_fields", tuple(new_streamable_fields))
         return streamable_type.from_json_dict(json_dict)
+    else:
+        return function_to_convert_one_item(  # type: ignore[return-value]
+            streamable_type,
+            functools.partial(
+                json_deserialize_with_clvm_streamable,
+                translation_layer=translation_layer,
+            ),
+        )(json_dict)
 
 
 _T_ClvmStreamable = TypeVar("_T_ClvmStreamable", bound="Streamable")