Version 0.0.3

Patch instance saving

Author: mos9527

README.md

@@ -12,6 +12,7 @@ Used in
 ## Usage
 Example usage in `rla_transport_defines`
 ```python
+env = UnityPy.load(...)
 from generated.Sekai.Streaming import TransportDefine
 from generated import UTTCGen_AsInstance
 
@@ -25,5 +26,5 @@ for reader in filter(lambda x: x.type == ClassIDType.MonoBehaviour, env.objects)
         # Possibly modify on the instance itself and saving it is also possible
         instance.validBones[0] = "BadBone"
         instance.save()
-
+env.save()
 ```

UnityPyTypetreeCodegen/__init__.py

@@ -1 +1 @@
-__version__ = (0, 0, 2)
+__version__ = (0, 0, 3)

UnityPyTypetreeCodegen/__main__.py

@@ -68,7 +68,7 @@
         "from UnityPy.classes.math import (ColorRGBA, Matrix3x4f, Matrix4x4f, Quaternionf, Vector2f, Vector3f, Vector4f, float3, float4,)",
         '''T = TypeVar("T")
 UTTCG_Classes = dict()
-def UTTCGen(fullname: str):
+def UTTCGen(fullname: str, typetree: dict):
     """dataclass-like decorator for typetree classess with nested type support
     
     limitations:
@@ -77,85 +77,56 @@ def UTTCGen(fullname: str):
     - generally supports nested types, however untested and could be slow	
     - and ofc, zero type checking and safeguards :/	
     """    
+    REFERENCED_ARGS = {'object_reader'}
     def __inner(clazz: T) -> T:
-        RESERVED_KWS = {'object_reader'}
         # Allow these to be propogated to the props
-        def __init__(self, **d):
-            def enusre_reserved(obj):
-                for k in RESERVED_KWS:
-                    if hasattr(obj, k) and k in d:
-                        setattr(obj, k, d[k])
-                return obj		
+        def __init__(self, **d):        
             def reduce_init(clazz, **d):
                 types : dict = clazz.__annotations__
                 for k, sub in types.items():
                     if type(sub) == str:
                         sub = eval(sub) # attrs turns these into strings...why?
+                    while sub.__name__ == "Optional":
+                        sub = sub.__args__[0]  # Reduce Optional[T] -> T
                     reduce_arg = getattr(sub, "__args__", [None])[0]
+                    if k in REFERENCED_ARGS: # Directly refcounted
+                        reduce_arg = sub = lambda x: x                         
                     if isinstance(d[k], list):
                         if hasattr(reduce_arg, "__annotations__"):
-                            setattr(self, k, [enusre_reserved(reduce_arg(**x)) for x in d[k]])
+                            setattr(self, k, [reduce_arg(**x) for x in d[k]])
                         else:
-                            setattr(self, k, [enusre_reserved(reduce_arg(x)) for x in d[k]])
+                            setattr(self, k, [reduce_arg(x) for x in d[k]])
                     elif isinstance(d[k], dict) and hasattr(sub, "__annotations__"):
-                        setattr(self, k, enusre_reserved(sub(**d[k])))
+                        setattr(self, k, sub(**d[k]))
                     else:
                         if isinstance(d[k], dict):
-                            setattr(self, k, enusre_reserved(sub(**d[k])))
+                            setattr(self, k, sub(**d[k]))
                         else:
-                            setattr(self, k, enusre_reserved(sub(d[k])))			
-            for __base__ in clazz.__bases__:
-                types : dict = __base__.__annotations__
-                args = {k:d[k] for k in types if k in d}
-                if len(args) == len(types):
-                    super(clazz, self).__init__(**args)
-                    reduce_init(__base__, **d)
-                    for k in args:
-                        if not k in RESERVED_KWS: del d[k]
-            reduce_init(clazz, **d)
-            enusre_reserved(self)
+                            setattr(self, k, sub(d[k]))
+            def reduce_base(clazz, **d):	
+                for __base__ in clazz.__bases__:
+                    if hasattr(__base__, "__annotations__"):
+                        types : dict = __base__.__annotations__
+                        args = {k:d[k] for k in types if k in d}
+                        if len(args) == len(types):
+                            super(clazz, self).__init__(**args)
+                            reduce_init(__base__, **d)                       
+                    reduce_base(__base__, **d)
+            reduce_base(clazz, **d)               
+            reduce_init(clazz, **d)            
         def __repr__(self) -> str:
             return f"{clazz.__name__}({', '.join([f'{k}={getattr(self, k)!r}' for k in self.__annotations__])})"
+        def __save(self):
+            self.object_reader.save_typetree(self, self.__typetree__)
         clazz.__init__ = __init__
         clazz.__repr__ = __repr__
+        clazz.__typetree__ = typetree
+        clazz.save = __save
         UTTCG_Classes[fullname] = clazz
         return clazz
     return __inner
 
 # Helper functions
-def UTTCGen_Reread(src: MonoBehaviour | ObjectReader, fullname: str = None) -> Tuple[dict, str]:
-    """Rereads the typetree data from the MonoBehaviour instance with our typetree definition.
-    
-    Args:
-        src: The MonoBehaviour instance or ObjectReader to read from.
-        fullname: The full name of the class to read. If None, it will be read from the MonoBehaviour instance's `m_Script` property.
-
-    Returns:
-        Tuple[dict, str]: [raw_def, fullname] where `raw_def` is the raw data read from the MonoBehaviour instance and `fullname` is the full name of the class.
-    """
-    if not fullname and isinstance(src, MonoBehaviour):
-        script = src.m_Script.read()
-        fullname = script.m_ClassName
-        if script.m_Namespace:
-            fullname = f"{script.m_Namespace}.{fullname}"    
-    definition = UTTCG_Typetrees.get(fullname, None)
-    assert definition is not None, f"Typetree definition for {fullname} not found"
-    if isinstance(src, MonoBehaviour):
-        src = src.object_reader
-    raw_def = src.read_typetree(definition, check_read=False)
-    return raw_def, fullname
-
-def UTTCGen_Instantiate(raw_def : dict, fullname: str):
-    """Instantiate a class from the typetree definition and the raw data.
-
-    Args:
-        raw_def (dict): The raw data read from the MonoBehaviour instance.
-        fullname (str): The full name of the class to instantiate.
-    """
-    clazz = UTTCG_Classes.get(fullname, None)
-    assert clazz is not None, f"Class definition for {fullname} not found"    
-    instance = clazz(**raw_def)
-    return instance
 
 def UTTCGen_AsInstance(src: MonoBehaviour | ObjectReader, fullname: str = None) -> T:
     """Instantiate a class from the typetree definition and the raw data.
@@ -170,8 +141,17 @@ def UTTCGen_AsInstance(src: MonoBehaviour | ObjectReader, fullname: str = None)
     Returns:
         T: An instance of the class defined by the typetree.
     """
-    raw_def, fullname = UTTCGen_Reread(src, fullname)
-    instance = UTTCGen_Instantiate(raw_def, fullname)
+    if not fullname and isinstance(src, MonoBehaviour):
+        script = src.m_Script.read()
+        fullname = script.m_ClassName
+        if script.m_Namespace:
+            fullname = f"{script.m_Namespace}.{fullname}"    
+    clazz = UTTCG_Classes.get(fullname, None)
+    assert clazz is not None, f"Class definition for {fullname} not found"    
+    if isinstance(src, MonoBehaviour):
+        src = src.object_reader
+    raw_def = src.read_typetree(clazz.__typetree__, check_read=False)
+    instance = clazz(object_reader=src, **raw_def)
     return instance
 ''',
     ]
@@ -348,7 +328,14 @@ def emit_line(*lines: str):
         clazz = translate_name(clazz)
         clazzes.append(clazz)
         clazz_fields = list()
-        emit_line(f"@UTTCGen('{fullname}')")
+
+        def __encoder(obj):
+            if isinstance(obj, TypeTreeNode):
+                return obj.__dict__
+            return obj
+
+        clazz_typetree = json.dumps(fields, default=__encoder)
+        emit_line(f"@UTTCGen('{fullname}', {clazz_typetree})")
         if lvl1:
             parent = translate_type(fields[0].m_Type, strip=True, fallback=False)
             emit_line(f"class {clazz}({parent}):")
@@ -454,15 +441,6 @@ def __open(fname: str):
             f = __open("__init__.py")
             process_namespace(f, classname_nodes, namespace)
 
-    def __encoder(obj):
-        if isinstance(obj, TypeTreeNode):
-            return obj.__dict__
-        return obj
-
-    __open("__init__.py").write(
-        "\nUTTCG_Typetrees = " + json.dumps(fullname_nodes, indent=4, default=__encoder)
-    )
-
 
 import re, logging
 from UnityPy.helpers.TypeTreeGenerator import TypeTreeGenerator