Greatly improve nested (e.g. godot->python->godot) attribute&method access, add support for virtual methods in bindings

Author: touilleMan

generation/bindings_templates/method.tmpl.pyx

@@ -147,12 +147,20 @@ with nogil:
 {% macro render_method(cls, method) %}
 # {{ render_method_c_signature(method) }}
 def {{ render_method_signature(method) }}:
-{% if method.is_supported %}
+{% if method.is_virtual %}
+    cdef Array args = Array()
+{%   for arg in method.arguments %}
+    args.append({{ arg.name }})
+{%   endfor %}
+    return Object.callv(self, "{{ method.name }}", args)
+{% else %}
+{%   if method.is_supported %}
     {{ _render_method_cook_args(method) | indent }}
     {{ _render_method_call(cls, method) | indent }}
     {{ _render_method_destroy_args(method) | indent }}
     {{ _render_method_return(method) | indent }}
-{% else %}
+{%   else %}
     raise NotImplementedError("{{method.unsupported_reason}}")
+{%   endif %}
 {% endif %}
 {% endmacro %}

pythonscript/_godot_instance.pxi

@@ -61,12 +61,28 @@ cdef api godot_bool pythonscript_instance_get_prop(
     const godot_string *p_name,
     godot_variant *r_ret
 ) with gil:
+    # Should look among properties added by the script and it parents,
+    # not Godot native properties that are handled by the caller
     cdef object instance = <object>p_data
     cdef object ret
+    cdef object field
+    cdef str key = godot_string_to_pyobj(p_name)
     try:
-        ret = getattr(instance, godot_string_to_pyobj(p_name))
-        pyobj_to_godot_variant(ret, r_ret)
+        field = instance.__exported[key]
+    except KeyError:
+        return False
+    try:
+        if isinstance(field, ExportedField):
+            ret = getattr(instance, godot_string_to_pyobj(p_name))
+            pyobj_to_godot_variant(ret, r_ret)
+        elif isinstance(field, SignalField):
+            # TODO: Not sure how to create a Variant::Signal from GDNative
+            return False
+        else:
+            # TODO: Not sure how to create a Variant::Callable from GDNative
+            return False
         return True
+
     except Exception:
         traceback.print_exc()
         return False
@@ -81,11 +97,12 @@ cdef api godot_variant pythonscript_instance_call_method(
 ) with gil:
     cdef godot_variant var_ret
     cdef object instance = <object>p_data
-    # TODO: optimize this by caching godot_string_name -> method lookup
-    try:
-        meth = getattr(instance, godot_string_name_to_pyobj(p_method))
+    cdef object fn
+    cdef str key = godot_string_name_to_pyobj(p_method)
 
-    except AttributeError:
+    # TODO: optimize this by caching godot_string_name -> method lookup
+    fn = instance.__exported.get(key)
+    if not callable(fn):
         r_error.error = godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_ERROR_INVALID_METHOD
         gdapi10.godot_variant_new_nil(&var_ret)
         return var_ret
@@ -95,7 +112,7 @@ cdef api godot_variant pythonscript_instance_call_method(
     cdef object ret
     try:
         pyargs = [godot_variant_to_pyobj(p_args[i]) for i in range(p_argcount)]
-        ret = meth(*pyargs)
+        ret = fn(instance, *pyargs)
         r_error.error = godot_variant_call_error_error.GODOT_CALL_ERROR_CALL_OK
         pyobj_to_godot_variant(ret, &var_ret)
         return var_ret
@@ -130,10 +147,11 @@ cdef api void pythonscript_instance_notification(
     # TODO: cache the methods to call ?
     for parentcls in instance.__class__.__mro__:
         try:
-            # TODO: Should only call _notification for class inheriting `bindings.Object` ?
-            parentcls.__dict__["_notification"](instance, p_notification)
-        except (KeyError, NotImplementedError):
+            fn = parentcls.__exported["_notification"]
+        except (AttributeError, KeyError):
             pass
+        else:
+            fn(instance, p_notification)
 
 
 # Useful ?

pythonscript/_godot_script.pxi

@@ -42,6 +42,8 @@ from godot.builtins cimport Array, Dictionary
 import inspect
 import traceback
 
+from godot.tags import ExportedField, SignalField
+
 
 cdef inline godot_pluginscript_script_manifest _build_empty_script_manifest():
     cdef godot_pluginscript_script_manifest manifest
@@ -125,23 +127,18 @@ cdef godot_pluginscript_script_manifest _build_script_manifest(object cls):
         pyobj_to_godot_string_name(base, &manifest.base)
 
     methods = Array()
-    # TODO: include inherited in exposed methods ? Expose Godot base class' ones ?
-    # for methname in vars(cls):
-    for methname in dir(cls):
-        meth = getattr(cls, methname)
-        if not is_method(meth) or meth.__name__.startswith("__") or methname.startswith('__'):
-            continue
-        methods.append(_build_method_info(meth, methname))
-    gdapi10.godot_array_new_copy(&manifest.methods, &methods._gd_data)
-
     signals = Array()
-    for signal in cls.__signals.values():
-        signals.append(_build_signal_info(signal))
-    gdapi10.godot_array_new_copy(&manifest.signals, &signals._gd_data)
-
     properties = Array()
-    for prop in cls.__exported.values():
-        properties.append(_build_property_info(prop))
+    for k, v in cls.__exported.items():
+        if isinstance(v, ExportedField):
+            properties.append(_build_property_info(v))
+        elif isinstance(v, SignalField):
+            signals.append(_build_signal_info(v))
+        else:
+            assert is_method(v)
+            methods.append(_build_method_info(v, k))
+    gdapi10.godot_array_new_copy(&manifest.methods, &methods._gd_data)
+    gdapi10.godot_array_new_copy(&manifest.signals, &signals._gd_data)
     gdapi10.godot_array_new_copy(&manifest.properties, &properties._gd_data)
 
     return manifest

pythonscript/godot/tags.pyx

@@ -209,6 +209,9 @@ class ExportedField:
         )
 
     def __call__(self, decorated):
+        if self.default is not None:
+            raise ValueError("export should not define a default attribute when used as a decorator")
+
         # This object is used as a decorator
         if not callable(decorated) and not isinstance(decorated, builtins.property):
             raise ValueError("@export should decorate function or property.")
@@ -248,15 +251,15 @@ def export(
     usage::
         @exposed
         class CustomObject(godot.bindings.Object):
-            a = exposed(str)  # Expose attribute
-            b = exposed(int, default=42)
+            a = export(str)  # Expose attribute
+            b = export(int, default=42)
 
-            @exposed(int)  # Expose property
+            @export(int)  # Expose property
             @property
             def c(self):
                 return 42
 
-            @exposed(str)  # Expose method
+            @export(str)  # Expose method
             def d(self):
                 return "foo"
     """
@@ -298,20 +301,17 @@ def exposed(cls=None, tool=False):
                 f" (already got {existing_cls_for_module!r})"
             )
 
-        # Overwrite parent __init__ to avoid creating a Godot object given
-        # exported script are always initialized with an existing Godot object
-        cls.__init__ = lambda self: None
         cls.__tool = tool
         cls.__exposed_python_class = True
         cls.__exported = {}
-        cls.__signals = {}
 
-        # Retrieve parent exported fields
+        # Retrieve parent exported stuff
         for b in cls.__bases__:
             cls.__exported.update(getattr(b, "__exported", {}))
-            cls.__signals.update(getattr(b, "__signals", {}))
 
-        # Collect exported fields
+        init_func_code = "def __init__(self):\n    pass\n"
+
+        # Collect exported stuff: attributes (marked with @exported), properties, signals, and methods
         for k, v in cls.__dict__.items():
             if isinstance(v, ExportedField):
                 cls.__exported[k] = v
@@ -321,11 +321,25 @@ def exposed(cls=None, tool=False):
                     # in the generated class
                     setattr(cls, k, v.property)
                 else:
-                    setattr(cls, k, v.default)
+                    # Otherwise, the value must be initialized as part of __init__
+                    if v.default is None or isinstance(v.default, (int, float, bool)):
+                        init_func_code += f"    self.{k} = {repr(v.default)}\n"
+                    else:
+                        init_func_code += f"    self.{k} = self.__exported['{k}'].default\n"
             elif isinstance(v, SignalField):
-                v.name = v.name if v.name else k
-                cls.__signals[v.name] = v
+                v.name = v.name or k
+                cls.__exported[v.name] = v
                 setattr(cls, k, v)
+            elif callable(v):
+                cls.__exported[k] = v
+
+        # Overwrite parent __init__ to avoid creating a Godot object given
+        # exported script are always initialized with an existing Godot object
+        # On top of that, we must initialize the attributes defined in the class
+        # and it parents
+        g = {}
+        exec(init_func_code, g)
+        cls.__init__ = g['__init__']
 
         set_exposed_class(cls)
         return cls