Move classes.pyx/pxd code into builtins.pyx/pxd (avoid recursive cimport)

Author: touilleMan

scripts/generate_tmpl.py

@@ -21,6 +21,7 @@
     "builtins.pxd": (False, GODOT_DIR),
     "builtins.pyx": (False, GODOT_DIR),
     "classes.pyi": (True, GODOT_DIR),
+    "singletons.pyi": (True, GODOT_DIR),
     "_classes_api.py": (True, GODOT_DIR),
     "utils.pyx": (False, GODOT_DIR),
     "utils.pyi": (False, GODOT_DIR),

src/godot/_lang.pyx

@@ -5,7 +5,6 @@ from .hazmat.gdextension_interface cimport *
 from .hazmat.gdapi cimport *
 from .hazmat cimport gdptrs
 from .builtins cimport *
-from .classes cimport _load_class, _load_singleton, _cleanup_loaded_classes_and_singletons, BaseGDObject
 
 #
 # Extensions definition

src/godot/_lang_script_language.pxi

@@ -1,4 +1,4 @@
-from .classes cimport ScriptLanguageExtensionProfilingInfo
+from .hazmat.gdtypes cimport ScriptLanguageExtensionProfilingInfo
 
 
 debug_spy = True

src/godot/builtins.pxd.j2

@@ -4,16 +4,64 @@ cimport cython
 from cpython.mem cimport PyMem_Malloc, PyMem_Free
 
 # Forward declarations
+cdef class BaseGDObject
 {% for builtin in api.builtins %}
 cdef class {{ builtin.cy_type }}
 {% endfor %}
 
 from .hazmat cimport gdapi, gdptrs, gdextension_interface
 from .hazmat.gdtypes cimport *
-from .classes cimport BaseGDObject
+
+
+##############################################################################
+#             Godot class dynamic generation & instance operations           #
+##############################################################################
+
+
+cpdef object _load_class(StringName name)
+cpdef BaseGDObject _load_singleton(str name)
+cdef void _cleanup_loaded_classes_and_singletons()
+cdef object _object_call(gd_object_t obj, StringName meth, list args)
+
+
+cdef class BaseGDObject:
+    cdef gd_object_t _gd_ptr
+
+    @staticmethod
+    cdef inline object steal_cast_from_variant(const gd_variant_t *gdvar):
+        """
+        Return `None` if the variant is not an object (and in this case the caller
+        is responsible to delete `gdvar`).
+        Don't increase the refcount if the variant is a refcounted object (hence the
+        "steal" in the name).
+        """
+        cdef gd_object_t obj = gdapi.gd_object_steal_from_variant(gdvar)
+        if obj == NULL:
+            return None
+        return BaseGDObject.steal_cast_from_object(obj)
+
+    @staticmethod
+    cdef inline object steal_cast_from_object(gd_object_t obj):
+        """
+        Return `None` if object is NULL.
+        Don't increase the refcount if the variant is a refcounted object (hence the
+        "steal" in the name).
+        """
+        if obj == NULL:
+            return None
+        # TODO: currently `Object.get_class` returns a `String` instead of a `StringName`
+        #       which is kind of wasteful...
+        cdef StringName class_name = StringName(_object_call(obj, StringName("get_class"), []))
+        cdef object klass = _load_class(class_name)
+        return klass._steal_from_ptr(<size_t>obj)
 
 
 {{ render_all_conversions() }}
+
+
+##############################################################################
+#                             Builtins wrappers                              #
+##############################################################################
 {% for builtin in api.builtins %}
 
 

src/godot/builtins.pyi.j2

@@ -86,6 +86,13 @@ class {{ builtin.cy_type }}:
     def clone(self) -> {{ builtin.py_type }}: ...
 {%   if builtin.members %}
 
+    # Operators
+{# TODO: include other operators! #}
+{# Note `Color` has a `hash` method, but it excluded since it is not an immutable type #}
+{% if builtin.original_name in ("String", "StringName", "NodePath", "Callable") %}
+    def __hash__(self): ...
+{% endif %}
+
     # Members
 {%   endif %}
 {%   for m in builtin.members %}

src/godot/builtins.pyx.j2

@@ -1,11 +1,13 @@
 {%- from 'builtins_pyx/class.pyx.j2' import render_class with context -%}
 {%- from 'builtins_pyx/conversion.pyx.j2' import render_all_conversions with context -%}
 cimport cython
+from cpython.ref cimport Py_INCREF, Py_DECREF, PyObject
 from cpython.mem cimport PyMem_Malloc, PyMem_Free
 from libc.math cimport INFINITY as inf  # Needed by some constants
 from libc.string cimport memset  # Needed to create zeroized builtins used in `__bool__`
 
 # Forward declarations
+cdef class BaseGDObject
 {% for builtin in api.builtins %}
 cdef class {{ builtin.cy_type }}
 {% endfor %}
@@ -48,12 +50,30 @@ from warnings import warn
 cdef object _SENTINEL = object()
 
 
+##############################################################################
+#             Godot class dynamic generation & instance operations           #
+##############################################################################
+
+
+include "builtins_classes.pxi"
+
+
 {{ render_all_conversions() }}
+
+
+##############################################################################
+#                             Builtins wrappers                              #
+##############################################################################
 {% for spec in api.builtins %}
 
 
 {{ render_class(spec) }}
 {% endfor %}
+
+
+##############################################################################
+#                               Global enums                                 #
+##############################################################################
 {% for spec in api.global_enums %}
 
 

src/godot/classes.pyx src/godot/builtins_classes.pxisrc/godot/classes.pyx renamed to src/godot/builtins_classes.pxi

@@ -1,24 +1,18 @@
-from cpython.ref cimport Py_INCREF, Py_DECREF, PyObject
-from .hazmat cimport gdapi, gdptrs, gdextension_interface
-from .hazmat.gdtypes cimport *
-from .builtins cimport *
+# This file is included by `builtins.pxd.j2`
 
 from enum import IntEnum
 import inspect
 from types import UnionType
 import dataclasses
 
 
-#####################################################################
-#                Godot classes exposed to Python                    #
-#####################################################################
+##############################################################################
+#                                BaseGDObject                                #
+##############################################################################
 
 
-def __getattr__(name: str):
-    try:
-        return _load_class(name)
-    except RuntimeError:
-        raise AttributeError
+# BaseGDObject is the parent class of all Godot classes
+# Note it is defined here instead of in `classes.pyx` to avoid recursive import
 
 
 cdef class BaseGDObject:
@@ -91,6 +85,11 @@ cdef class BaseGDObject:
         return wrapper
 
 
+#####################################################################
+#                Godot classes exposed to Python                    #
+#####################################################################
+
+
 cdef object _loaded_singletons = {}
 cdef object _loaded_classes = {}
 
@@ -106,14 +105,13 @@ cpdef BaseGDObject _load_singleton(str name):
     except KeyError:
         pass
 
-    cdef object cls = _load_class(name)
-    cdef gd_string_name_t gdname = gdapi.gd_string_name_from_unchecked_pystr(name)
-    cdef gd_object_t gdobj = gdptrs.gdptr_global_get_singleton(&gdname)
-    gdapi.gd_string_name_del(&gdname)
+    cdef StringName gd_name = StringName(name)
+    cdef gd_object_t gdobj = gdptrs.gdptr_global_get_singleton(&gd_name._gd_data)
 
     if gdobj == NULL:
         raise RuntimeError(f"Singleton `{name}` doesn't exist in Godot !")
 
+    cdef object cls = _load_class(gd_name)
     cdef BaseGDObject singleton = <BaseGDObject>cls._steal_from_ptr(<size_t>gdobj)
 
     _loaded_singletons[name] = singleton
@@ -132,29 +130,24 @@ cdef inline object _meth_call(BaseGDObject obj, object name, object args):
     return _object_call(obj._gd_ptr, StringName("call"), [name, *args])
 
 
-cdef object _load_class(str name):
-    try:
-        return _loaded_classes[name]
-    except KeyError:
-        pass
+cdef inline object _build_class_from_spec(str name, StringName gd_name):
+    # TODO: ClassDB won't be needed once method uses ptrcall
+    # Load our good friend ClassDB
+    cdef StringName gdname_classdb = StringName("ClassDB")
+    cdef gd_object_t classdb = gdptrs.gdptr_global_get_singleton(&gdname_classdb._gd_data)
 
     from godot import _classes_api
+    cdef list spec
     try:
         spec = getattr(_classes_api, name)
     except AttributeError:
         raise RuntimeError(f"Class `{name}` doesn't exist in Godot !")
 
-    # TODO: ClassDB won't be needed once method uses ptrcall
-    # Load our good friend ClassDB
-    cdef StringName gdname_classdb = StringName("ClassDB")
-    cdef gd_object_t classdb = gdptrs.gdptr_global_get_singleton(&gdname_classdb._gd_data)
-
-    cdef StringName gd_name = StringName(name)
     parent = spec[0]
     is_refcounted = spec[1]
     items_spec = iter(spec[2:])
     if parent:
-        parent_cls = _load_class(parent)
+        parent_cls = _load_class(StringName(parent))
         bases = (parent_cls, )
     else:
         bases = (BaseGDObject, )
@@ -163,20 +156,23 @@ cdef object _load_class(str name):
 
     if not is_refcounted and name == "RefCounted":
 
+        def _gen():
+            cdef StringName gdstr_unreference = StringName("unreference")
+
             def _del(self):
                 print(f'[DEBUG] {type(self).__name__}.__del__()', flush=True)
                 cdef BaseGDObject obj = <BaseGDObject>self
-                if _object_call(obj._gd_ptr, StringName("unreference"), []):
+                if _object_call(obj._gd_ptr, gdstr_unreference, []):
                     gdptrs.gdptr_object_destroy(obj._gd_ptr)
                     obj._gd_ptr = NULL
 
-            attrs["__del__"] = _del
-
             def _free(self):
                 print(f'[DEBUG] {type(self).__name__}.free()', flush=True)
                 raise RuntimeError("RefCounted Godot object, cannot be freed")
 
-            attrs["free"] = _free
+            return _del, _free
+
+        attrs["__del__"], attrs["free"] = _gen()
 
     while True:
         try:
@@ -293,9 +289,18 @@ cdef object _load_class(str name):
     # `Object` defines a `free`, but it doesn't work properly (instead we rely on `BaseGDObject.free`)
     attrs.pop("free", None)
 
-    cdef object klass = type(name, bases, attrs)
+    return type(name, bases, attrs)
+
+
+cpdef object _load_class(StringName gd_name):
+    try:
+        return _loaded_classes[gd_name]
+    except KeyError:
+        pass
+
+    cdef object klass = _build_class_from_spec(str(gd_name), gd_name)
 
-    _loaded_classes[name] = klass
+    _loaded_classes[gd_name] = klass
     return klass
 
 

src/godot/builtins_pyx/operator.pyx.j2

@@ -30,6 +30,15 @@ def __repr__(self):
         gdapi.gd_string_del(&gdstr)
 {%   endif %}
 
+{# Note `Color` has a `hash` method, but it excluded since it is not an immutable type #}
+{% if builtin.original_name in ("String", "StringName", "NodePath", "Callable") %}
+def __hash__(self):
+    cdef int64_t ret = gdapi.gd_{{ builtin.snake_name }}_meth_hash(
+        &self._gd_data,
+    )
+    return ret
+{% endif %}
+
 def __eq__(self, object other):
     cdef {{ builtin.c_type }}* other_gd_data
     try:

src/godot/classes.pxd

@@ -0,0 +1,8 @@
+from .builtins import _load_class, StringName
+
+
+def __getattr__(name: str) -> type:
+    try:
+        return _load_class(StringName(name))
+    except RuntimeError:
+        raise AttributeError