Improve code generation

Author: touilleMan

scripts/generate_builtins.py

@@ -0,0 +1,90 @@
+#! /usr/bin/env python3
+
+import argparse
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from extension_api_parser import BuildConfig, parse_extension_api_json, ExtensionApi
+
+
+BASEDIR = Path(__file__).parent
+
+
+def make_jinja_env(import_dir: Path) -> Environment:
+    env = Environment(
+        loader=FileSystemLoader(import_dir),
+        trim_blocks=True,
+        lstrip_blocks=False,
+        extensions=["jinja2.ext.loopcontrols"],
+        undefined=StrictUndefined,
+    )
+    env.filters["merge"] = lambda x, **kwargs: {**x, **kwargs}
+    return env
+
+
+def generate_gdapi_ptrs(api: ExtensionApi) -> str:
+    env = make_jinja_env(BASEDIR / "../src/godot/_hazmat")
+    template = env.get_template("gdapi_ptrs.tmpl.pxi")
+    return template.render(api=api)
+
+
+def generate_builtins_pxd(api: ExtensionApi) -> str:
+    env = make_jinja_env(BASEDIR / "../src/godot")
+    template = env.get_template("_builtins.tmpl.pxd")
+    return template.render(api=api)
+
+
+def generate_builtins_pyx(api: ExtensionApi) -> str:
+    env = make_jinja_env(BASEDIR / "../src/godot")
+    template = env.get_template("_builtins.tmpl.pyx")
+    return template.render(api=api)
+
+
+def generate_builtins_pyi(api: ExtensionApi) -> str:
+    env = make_jinja_env(BASEDIR / "../src/godot")
+    template = env.get_template("_builtins.tmpl.pyi")
+    return template.render(api=api)
+
+
+OUTPUT_TO_FN = {
+    "gdapi_ptrs.pxi": generate_gdapi_ptrs,
+    "_builtins.pxd": generate_builtins_pxd,
+    "_builtins.pyx": generate_builtins_pyx,
+    "_builtins.pyi": generate_builtins_pyi,
+}
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Generate code from templates")
+    parser.add_argument(
+        "--input",
+        "-i",
+        required=True,
+        metavar="EXTENSION_API_PATH",
+        type=Path,
+        help="Path to Godot extension_api.json file",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        required=True,
+        type=Path,
+        help=f"pyx/pxd/pyi to generate (choices: {', '.join(OUTPUT_TO_FN.keys())})",
+    )
+    parser.add_argument(
+        "--build-config",
+        required=True,
+        type=BuildConfig,
+        choices=BuildConfig,
+        help=f"choices: {', '.join([x.value for x in BuildConfig])}",
+        metavar="CONFIG",
+    )
+
+    args = parser.parse_args()
+
+    api = parse_extension_api_json(path=args.input, build_config=args.build_config)
+
+    # We use # in the name to simulate folder hierarchy in the meson build
+    *_, name = args.output.name.rsplit("#", 1)
+    code = OUTPUT_TO_FN[name](api)
+    args.output.write_text(code, encoding="utf8")

scripts/generate_tmpl.py

@@ -15,7 +15,7 @@
 #     godot_pluginscript_language_data,
 # )
 # from godot._hazmat.internal cimport set_pythonscript_verbose, get_pythonscript_verbose
-# from godot.builtins cimport GDString
+from godot._builtins cimport GDString, Vector2
 
 # def _setup_config_entry(name, default_value):
 #     gdname = GDString(name)
@@ -43,6 +43,10 @@ cdef api void _pythonscript_initialize() with gil:
     cooked_sys_version = '.'.join(map(str, sys.version_info))
     print(f"Pythonscript {pythonscript_version} (CPython {cooked_sys_version})")
     print(f"PYTHONPATH: {sys.path}")
+    v = Vector2(3., 2.)
+    v2 = Vector2(v)
+    print("===========>", v.x, v.y)
+    print("+++++++++++>", v2.x, v2.y)
 
 
     # # OS and ProjectSettings are singletons exposed as global python objects,

src/_pythonscript.pyx

@@ -0,0 +1,3 @@
+from ._builtins cimport *
+# from ._bindings cimport *
+from . cimport _hazmat

src/godot/__init__.pxd

@@ -32,14 +32,6 @@
 #     export,
 #     exposed,
 # )
-# from godot.pool_arrays import (
-#     PoolIntArray,
-#     PoolRealArray,
-#     PoolByteArray,
-#     PoolVector2Array,
-#     PoolVector3Array,
-#     PoolColorArray,
-#     PoolStringArray,
-# )
-# from godot.builtins import *
+from godot._builtins import *
+
 # from godot.bindings import *

src/godot/__init__.py

@@ -1,3 +1,15 @@
-{%- from '_builtin.tmpl.pxi' import render_spec -%}
 # /!\ Autogenerated code, modifications will be lost /!\
-# see `generation/generate_builtins.py`
+# see `scripts/generate_tmpl.py`
+
+cimport cython
+{% for spec in api["builtins"] if not spec.is_scalar %}
+
+
+@cython.freelist(8)
+@cython.final
+cdef class {{ spec.name }}:
+    cdef char _gd_data[{{ spec.size }}]
+
+    @staticmethod
+    cdef inline {{ spec.name }} new()
+{% endfor %}

src/godot/_builtins.tmpl.pxd

@@ -1,18 +1,20 @@
 # /!\ Autogenerated code, modifications will be lost /!\
-# see `generation/generate_builtins.py`
+# see `scripts/generate_tmpl.py`
 
 
 class GDObject:
     ...
 
 
-GDVariant = None | GDObject | {{ specs | map(attribute="name") | join(" | ") }}
+# GDAny represent any type that can be send to / retreive from Godot
+# (i.e. it is all the types than can be converted to a Godot Variant)
+GDAny = None | GDObject | {{ api["builtins"] | map(attribute="name") | join(" | ") }}
 
 {% macro render_arg(arg) -%}
-{{arg.name}}: {{ arg.type.name if arg.type.name != "GDString" else "GDString | str"}}{{ "={}".format(arg.default_value) if arg.default_value is not none }}
+{{arg.name}}: {{ arg.type.py_type if arg.type.py_type != "GDString" else "GDString | str"}}{{ "={}".format(arg.default_value.value) if arg.default_value is not none }}
 {%- endmacro %}
 
-{% for spec in specs %}
+{% for spec in api["builtins"] if not spec.is_scalar %}
 
 class {{spec.name}}:
 {% for c in spec.constructors %}
@@ -22,19 +24,19 @@ class {{spec.name}}:
     # Members
 {% endif %}
 {% for m in spec.members %}
-    {{m.name}}: {{ m.type.name }}
+    {{m.name}}: {{ m.type.py_type }}
 {% endfor %}
 {% if spec.methods %}
     # Methods
 {% endif %}
 {% for m in spec.methods %}
-    def {{m.name}}(self{% for a in m.arguments %}, {{ render_arg(a) }}{% endfor %}) -> {{ m.return_type.name if m.return_type is not none else "None" }}: ...
+    def {{m.name}}(self{% for a in m.arguments %}, {{ render_arg(a) }}{% endfor %}) -> {{ m.return_type.py_type if m.return_type is not none else "None" }}: ...
 {% endfor %}
 {% if spec.constants %}
     # Constants
 {% endif %}
 {% for c in spec.constants %}
-    {{c.name}}: {{c.type.name}}
+    {{c.name}}: {{c.type.py_type}}
 {% endfor %}
 
 {% endfor %}

src/godot/_builtins.tmpl.pyi

@@ -1,13 +1,13 @@
-{%- from '_builtin.tmpl.pxi' import render_spec -%}
+{%- from '_builtins_pyx/class.tmpl.pxi' import render_spec -%}
 # /!\ Autogenerated code, modifications will be lost /!\
-# see `generation/generate_builtins.py`
+# see `scripts/generate_tmpl.py`
 
 cimport cython
 from libc.math cimport INFINITY as inf  # Needed by some constants
 
-from godot._hazmat.gdnative_interface cimport *
-from godot._hazmat.gdapi cimport pythonscript_gdapi as gdapi
+from ._hazmat.gdnative_interface cimport *
+from ._hazmat.gdapi cimport pythonscript_gdapi as gdapi
 
-{% for item in specs -%}
-{{     render_spec(item) }}
+{% for spec in api["builtins"] if not spec.is_scalar -%}
+{{     render_spec(spec) }}
 {% endfor %}

src/godot/_builtins.tmpl.pyx

@@ -1,25 +1,17 @@
+{%- from '_builtins_pyx/constructor.tmpl.pxi' import render_constructor -%}
+{%- from '_builtins_pyx/gdapi.tmpl.pxi' import render_gdapi -%}
+
 {% macro render_spec(spec) -%}
 
-{% for c in spec.constructors %}
-cdef GDNativePtrConstructor __{{ spec.name }}_constructor_{{ c.index }} = gdapi.variant_get_ptr_constructor(
-    {{ spec.variant_type_name }}, {{ c.index }}
-)
-{% endfor %}
-{% if spec.has_destructor %}
-cdef GDNativePtrDestructor __{{ spec.name }}_destructor = gdapi.variant_get_ptr_destructor(
-    {{ spec.variant_type_name }}
-)
-{% endif %}
+{{ render_gdapi(spec) }}
 
+@cython.freelist(8)
 @cython.final
 cdef class {{ spec.name }}:
 {# TODO: I guess only Nil has no size, so remove it and only use None ? #}
 {% if spec.size %}
-    cdef char _gd_data[{{ spec.size }}]
-
     # Constructors
-    def __init__({{ spec.name }} self):
-        __{{ spec.name }}_constructor_0(self._gd_data, NULL)
+    {{ render_constructor(spec) | indent }}
 
     @staticmethod
     cdef inline {{ spec.name }} new():
@@ -32,7 +24,7 @@ cdef class {{ spec.name }}:
 {% if spec.has_destructor %}
     # Destructor
     def __dealloc__({{ spec.name }} self):
-        # /!\ if `__init__` is skipped, `_gd_data` must be initialized by
+        # /!\ if `__cinit__` is skipped, `_gd_data` must be initialized by
         # hand otherwise we will get a segfault here
         __{{ spec.name }}_destructor(self._gd_data)
 {% else %}
@@ -49,12 +41,41 @@ cdef class {{ spec.name }}:
 
 {% endif %}
 {% for c in spec.constants %}
-    {{ c.name }} = {{ c.value }}
+    # {{ c.name }} = {{ c.value }}
+{% endfor %}
+
+{% if spec.members %}
+    # Members
+{% endif %}
+{% for m in spec.members %}
+    @property
+    def {{ m.name }}(self) -> {{ m.type.py_type }}:
+{%   if m.offset is not none %}
+{%     if m.type.is_scalar %}
+        return (<{{ m.type.c_type }}*>self._gd_data)[{{ m.offset }}]
+{#   TODO: ensure m.type doesn't need a destructor #}
+{%     else %}
+{#      TODO: Find a way to avoid this copy ? #}
+        cdef {{ m.type.py_type }} ret = {{ m.type.py_type }}.__new__()  # Skips __init__()
+        ret._gd_data = self._gd_data
+        return ret
+{%     endif %}
+    @{{ m.name }}.setter
+    def {{ m.name }}(self, {{ m.type.py_type }} value) -> None:
+{%     if m.type.is_scalar %}
+        (<{{ m.type.c_type }}*>self._gd_data)[{{ m.offset }}] = value
+{#   TODO: ensure m.type doesn't need a destructor #}
+{%     else %}
+        self._gd_data = value._gd_data
+{%     endif %}
+{%   else %}
+        # TODO: support properties !
+        raise NotImplementedError
+{%   endif %}
 {% endfor %}
 
 {% if spec.methods %}
     # Methods
-
 {% endif %}
 {% for m in spec.methods %}
     def {{ m.name }}(
@@ -75,7 +96,7 @@ cdef class {{ spec.name }}:
 {% if m.arguments | length == 0 %}
 # {%     if m.return_type %}
 #         # TODO
-#         # cdef {{ m.return_type.cython_name }} ret = {{ m.return_type.cython_name }}.__new__()
+#         # cdef {{ m.return_type.cy_type }} ret = {{ m.return_type.cy_type }}.__new__()
 # {%         set retval_as_arg = "NULL" %}
 # {%     else %}
 # {%         set retval_as_arg = "NULL" %}

src/godot/_builtin.tmpl.pxi renamed to src/godot/_builtins_pyx/class.tmpl.pxi

@@ -0,0 +1,54 @@
+{% macro render_constructor(spec) -%}
+
+{% for constructor in spec.constructors %}
+# {{ constructor.index }} {{ constructor.arguments }}
+{% endfor %}
+
+{% if spec.name == "Vector2" %}
+
+def __cinit__({{ spec.name }} self, x=None, y=None):
+    cdef GDNativeTypePtr args[2]
+    cdef float args_x
+    cdef float args_y
+    if y is None:
+        if x is None:
+            __{{ spec.name }}_constructor_0(self._gd_data, NULL)
+            return
+
+        try:
+            args[0] = (<Vector2>x)._gd_data
+        except TypeError:
+
+            try:
+                args[0] = (<Vector2i>x)._gd_data
+            except TypeError:
+                pass
+
+            else:
+                # Constructor from Vector2i
+                __{{ spec.name }}_constructor_2(self._gd_data, args)
+                return
+
+        else:
+            # Constructor from Vector2
+            __{{ spec.name }}_constructor_1(self._gd_data, args)
+            return
+
+    elif isinstance(x, (float, int)) and isinstance(y, (float, int)):
+        args_x = x
+        args_y = y
+        args[0] = &args_x
+        args[1] = &args_y
+        __{{ spec.name }}_constructor_3(self._gd_data, args)
+        return
+
+    raise TypeError(f"Expected x&y as int/float, or x as Vector2/Vector2i")
+
+{% else %}
+
+def __cinit__({{ spec.name }} self):
+    __{{ spec.name }}_constructor_0(self._gd_data, NULL)
+
+{% endif %}
+
+{% endmacro %}