Use pre-generated spec for classes.pyx

Author: touilleMan

scripts/generate_tmpl.py

@@ -18,11 +18,10 @@
     "gdtypes.pxd": (False, HAZMAT_DIR),
     "gdapi.pxd": (False, HAZMAT_DIR),
     "builtins.pyi": (False, GODOT_DIR),
-    "builtins.pxd": (True, GODOT_DIR),
-    "builtins.pyx": (True, GODOT_DIR),
+    "builtins.pxd": (False, GODOT_DIR),
+    "builtins.pyx": (False, GODOT_DIR),
     "classes.pyi": (True, GODOT_DIR),
-    "classes.pxd": (True, GODOT_DIR),
-    "classes.pyx": (True, GODOT_DIR),
+    "_classes_api.py": (True, GODOT_DIR),
     "conversion.pyx": (False, GODOT_DIR),
     "conversion.pxd": (False, GODOT_DIR),
 }
@@ -41,6 +40,7 @@
     "Font",
     "Image",
     "InputEvent",
+    "JSON",
     "MainLoop",
     "Node",
     "Node2D",
@@ -86,6 +86,7 @@ def make_jinja_env(import_dir: Path) -> Environment:
     )
     env.filters["merge"] = lambda x, **kwargs: {**x, **kwargs}
     env.filters["gd_description_to_py_doc"] = gd_description_to_py_doc
+    env.filters["repr"] = repr
     return env
 
 

src/godot/_classes_api.py.j2

@@ -0,0 +1,180 @@
+# Constant definition:
+# [ ...
+#   "_c",
+#   <constant_name as str>,
+#   <constant_value as  int>,
+# ...]
+_tag_constant = "_c"
+
+# Enum definition:
+# [ ...
+#   "_e",
+#   <enum_name as str>,
+#   <enum_items_count as int>,
+#   # First item
+#   <enum_item_name as str>,
+#   <enum_item_value as int>,
+#   # Additional items
+#   ...
+# ...]
+_tag_enum = "_e"
+
+# Property definition:
+# [ ...
+#   "_p",
+#   <property_name as str>,
+#   <property_type as  str>,
+#   <property_getter as str>,
+#   <property_setter as str or None>,
+#   <property_index as int or None>,
+# ...]
+_tag_property = "_p"
+
+# Signal definition:
+# [ ...
+#   "_s",
+#   <signal_name as str>,
+#   <signal_arguments_count as int>,
+#   # First argument
+#   <argument_name as str>,
+#   <argument_type as str>,
+#   <argument_default_value as str or None>,
+#   # Additional argument
+#   ...
+# ...]
+_tag_signal = "_s"
+
+# Method definition:
+# [ ...
+#   "_m",
+#   <method_name as str>,
+#   <method_hash as int>,
+#   <method_flags as int>,
+#   <method_return_type as str>,
+#   <method_arguments_count as int>,
+#   # First argument
+#   <argument_name as str>,
+#   <argument_type as str>,
+#   <argument_default_value as str or None>,
+#   # Additional argument
+#   ...
+# ...]
+_tag_method = "_m"
+_tag_method_flag_is_const = 1 << 1
+_tag_method_flag_is_vararg = 1 << 2
+_tag_method_flag_is_static = 1 << 3
+_tag_method_flag_is_virtual = 1 << 4
+_tag_method_flag_is_required = 1 << 5
+_tag_method_flag_is_property_accessor = 1 << 6
+
+
+{% for c in api.classes %}
+{{ c.original_name }} = [
+    # Parent
+{%   if c.inherits is none %}
+    None,
+{%   else %}
+    "{{ c.inherits.type_name }}",
+{%   endif %}
+
+    # constants
+{%   for constant in c.constants %}
+
+    _tag_constant,
+    "{{ constant.name }}",
+    {{ constant.value }},
+{%   endfor %}
+
+    # enums
+{%   for enum in c.enums %}
+
+    _tag_enum,
+    "{{ enum.original_name }}",
+    {{ enum.items | length }},  # Items count
+{%     for item in enum.items %}
+    "{{ item.py_name }}",
+    {{ item.value }},
+{%     endfor %}
+{%   endfor %}
+
+    # properties
+{%   for prop in c.properties %}
+
+    _tag_property,
+    "{{ prop.name }}",
+    # type
+    "{{ prop.type.type_name }}",
+    # getter
+    "{{ prop.getter }}",
+    # setter
+{%     if prop.setter is none %}
+    None,
+{%     else %}
+    "{{ prop.setter }}",
+{%     endif %}
+    # index
+{%     if prop.index is none %}
+    None,
+{%     else %}
+    {{ prop.index }},
+{%     endif %}
+{%   endfor %}
+
+    # signals
+{%   for signal in c.signals %}
+
+    _tag_signal,
+    "{{ signal.name }}",
+    {{ signal.arguments | length }},  # Arguments count
+{%     for signal_arg in signal.arguments %}
+    "{{ signal_arg.name }}",
+    "{{ signal_arg.type.type_name }}",
+{%       if signal_arg.default_value is none %}
+    None,  # No default value
+{%       else %}
+    {{ signal_arg.default_value.py_value | repr }},  # Default value
+{%       endif %}
+{%     endfor %}
+{%   endfor %}
+
+    # methods
+{%   for method in c.methods %}
+
+    _tag_method,
+    "{{ method.name }}",
+    {{ method.hash }}, # Hash
+    (
+        0
+{%     if method.is_const %}
+        | _tag_method_flag_is_const
+{% endif %}
+{%     if method.is_vararg %}
+        | _tag_method_flag_is_vararg
+{% endif %}
+{%     if method.is_static %}
+        | _tag_method_flag_is_static
+{% endif %}
+{%     if method.is_virtual %}
+        | _tag_method_flag_is_virtual
+{% endif %}
+{%     if method.is_required %}
+        | _tag_method_flag_is_required
+{% endif %}
+{%     if method.is_property_accessor %}
+        | _tag_method_flag_is_property_accessor
+{% endif %}
+    ),
+    "{{ method.return_type.type_name }}",  # Return type
+    {{ method.arguments | length }},  # Arguments count
+{%     for method_arg in method.arguments %}
+    "{{ method_arg.name }}",
+    "{{ method_arg.type.type_name }}",
+{%       if method_arg.default_value is none %}
+    None,  # No default value
+{%       else %}
+    {{ method_arg.default_value.py_value | repr }},  # Default value
+{%       endif %}
+{%     endfor %}
+{%   endfor %}
+]
+{% endfor %}

src/godot/classes.pxd

@@ -0,0 +1,32 @@
+from .hazmat cimport gdapi
+from .hazmat.gdtypes cimport *
+
+
+cdef class BaseGDObject:
+    cdef gd_object_t _gd_ptr
+
+    @staticmethod
+    cdef inline object cast_from_variant(const gd_variant_t *gdvar):
+        # TODO: cast to remove const due to `GDExtensionTypeFromVariantConstructorFunc`
+        cdef gd_object_t obj = gdapi.gd_object_from_variant(<gd_variant_t *>gdvar)
+        if obj == NULL:
+            return None
+        cdef object class_name = _object_call(obj, "get_class", [])
+        # TODO: Kind of wasteful to have to convert Godot string here...
+        cdef object klass = _load_class(str(class_name))
+        return klass._from_ptr(<size_t>obj)
+
+    @staticmethod
+    cdef inline object cast_from_object(gd_object_t obj):
+        if obj == NULL:
+            return None
+        cdef object class_name = _object_call(obj, "get_class", [])
+        # TODO: Kind of wasteful to have to convert Godot string here...
+        cdef object klass = _load_class(str(class_name))
+        return klass._from_ptr(<size_t>obj)
+
+
+cdef object _load_class(str name)
+cpdef BaseGDObject _load_singleton(str name)
+cdef void _cleanup_loaded_classes_and_singletons()
+cdef object _object_call(gd_object_t obj, str meth, list args)