From 18f75eed2585dc60056a7d0dcd35432563745ba5 Mon Sep 17 00:00:00 2001
From: Jonas Holzman <jonas@holzman.fr>
Date: Thu, 20 Mar 2025 15:12:18 +0100
Subject: [PATCH] Initial Dumper static functions cleanup

---
 core/dumper.py | 51 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git a/core/dumper.py b/core/dumper.py
index b36cb1b..803f1d9 100644
--- a/core/dumper.py
+++ b/core/dumper.py
@@ -1,61 +1,61 @@
 import bpy
-import mathutils
-from pprint import pprint
-import json
-import itertools
 from copy import copy
 from os.path import abspath
+from pprint import pprint
 
 
-def get_default(prop):
-    """Get the default value of a bl property"""
-
+def get_default(prop: bpy.types.Property):
+    """Get the default value of a Blender property"""
     if getattr(prop, "is_array", False):
         return list(prop.default_array)
     elif hasattr(prop, "default"):
         return prop.default
 
 
-def get_dumper(bl_object, fallback=None):
-    """Find the right dumper type by checking inheritance"""
+def get_dumper(bl_object: bpy.types.bpy_struct):
+    """Get the corresponding dumper for a given Blender object, or its closest base type"""
     for dp in dumpers:
-        if isinstance(bl_object, dp.bl_type):
+        if isinstance(bl_object, dp.bl_type):  # TODO: Cascade system
             return dp
 
-    return fallback or Dumper
+    return Dumper or None
 
 
-def get_bl_object(data):
-    """Find the bl object for loading data into it depending on the type and the context"""
+def get_current_node_tree(data):
     if data.get("_new", {}).get("type") == "GeometryNodeTree":
         return bpy.context.object.modifiers.active.node_group
 
 
-def dump_nodes(ob):
+def dump_nodes(nodes: list[bpy.types.Node]):
     """Generic Recursive Dump, convert any object into a dict"""
-    Dumper.pointers.clear()
+    Dumper.pointers.clear()  # TODO: Bad global
 
-    if isinstance(ob, (list, tuple)):
-        data = [get_dumper(o).dump(o) for o in ob]
-    else:
-        data = get_dumper(ob).dump(ob)
+    data = [dump_node(node) for node in nodes]
 
     Dumper.pointers.clear()
+    
+    print("---")
+    pprint(data)
+    print("---")
 
     return data
 
+def dump_node(node: bpy.types.Node):
+    dumper = get_dumper(node)
+    return dumper.dump(node)  # TODO: Break the recursivity, clear things up
 
-def load_nodes(data, bl_object=None):
+
+def load_nodes(data, node_tree=None):
     """Generic Load to create an object from a dict"""
 
     Dumper.pointers.clear()
     # print(Dumper.pointers)
 
-    if bl_object is None:
-        bl_object = get_bl_object(data)
+    if node_tree is None:
+        node_tree = get_current_node_tree(data)
 
-    dumper = get_dumper(bl_object)
-    dumper.load(data, bl_object)
+    dumper = get_dumper(node_tree)
+    dumper.load(data, node_tree)
 
     Dumper.pointers.clear()
 
@@ -96,7 +96,6 @@ class Dumper:
         if bl_object is None:
             return
 
-        # pprint(data)
         if bl_pointer := data.get("bl_pointer"):
             cls.pointers[bl_pointer] = bl_object
 
@@ -114,7 +113,7 @@ class Dumper:
                 dumper = PropCollection
                 if hasattr(attr, "bl_rna"):
                     bl_type = attr.bl_rna.type_recast()
-                    dumper = get_dumper(bl_type, fallback=PropCollection)
+                    dumper = PropCollection or get_dumper(bl_type)
 
                 dumper.load(value, attr)
                 continue