panda3d-interrogate 0.1.0__tar.gz → 0.2.0__tar.gz

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panda3d-interrogate
-Version: 0.1.0
+Version: 0.2.0
 Summary: Binding generator designed for Panda3D
 License: Copyright (c) 2008, Carnegie Mellon University.
         All rights reserved.

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/cmake/macros/Python.cmake

@@ -47,8 +47,14 @@ function(add_python_target target)
   endforeach(arg)
 
   string(REGEX REPLACE "^.*\\." "" basename "${module_name}")
-  string(REGEX REPLACE "\\.[^.]+$" "" namespace "${module_name}")
-  string(REPLACE "." "/" slash_namespace "${namespace}")
+
+  if(module_name MATCHES "[.]")
+    string(REGEX REPLACE "\\.[^.]+$" "" namespace "${module_name}")
+    string(REPLACE "." "/" slash_namespace "/${namespace}")
+  else()
+    set(namespace "")
+    set(slash_namespace "")
+  endif()
 
   if(CMAKE_VERSION VERSION_LESS "3.26")
     add_library(${target} ${MODULE_TYPE} ${sources})
@@ -62,7 +68,7 @@ function(add_python_target target)
   endif()
 
   if(NOT MODULE_TYPE STREQUAL "STATIC")
-    set(_outdir "${PANDA_OUTPUT_DIR}/${slash_namespace}")
+    set(_outdir "${PANDA_OUTPUT_DIR}${slash_namespace}")
 
     set_target_properties(${target} PROPERTIES
       LIBRARY_OUTPUT_DIRECTORY "${_outdir}"
@@ -78,7 +84,7 @@ function(add_python_target target)
     endforeach(_config)
 
     if(PYTHON_ARCH_INSTALL_DIR)
-      install(TARGETS ${target} EXPORT "${export}" COMPONENT "${component}" DESTINATION "${PYTHON_ARCH_INSTALL_DIR}/${slash_namespace}")
+      install(TARGETS ${target} EXPORT "${export}" COMPONENT "${component}" DESTINATION "${PYTHON_ARCH_INSTALL_DIR}${slash_namespace}")
     endif()
 
   else()

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "panda3d-interrogate"
-version = "0.1.0"
+version = "0.2.0"
 description = "Binding generator designed for Panda3D"
 readme = "README.md"
 requires-python = ">=3.2"

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/src/dtoolbase/pdtoa.cxx

@@ -27,6 +27,7 @@ THE SOFTWARE.
 #include <math.h>
 #include <stdint.h>
 #include <string.h>
+#include <cmath>
 
 #if defined(_MSC_VER)
 #include <intrin.h>

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/src/interrogatedb/dtool_super_base.cxx

@@ -61,8 +61,18 @@ static void Dtool_FreeInstance_DTOOL_SUPER_BASE(PyObject *self) {
  */
 Dtool_PyTypedObject *Dtool_GetSuperBase() {
   Dtool_TypeMap *type_map = Dtool_GetGlobalTypeMap();
+
+  // If we don't have the GIL, we have to protect this with a lock to make
+  // sure that there is only one DTOOL_SUPER_BASE instance in the world.
+#ifdef Py_GIL_DISABLED
+  PyMutex_Lock(&type_map->_lock);
+#endif
+
   auto it = type_map->find("DTOOL_SUPER_BASE");
   if (it != type_map->end()) {
+#ifdef Py_GIL_DISABLED
+    PyMutex_Unlock(&type_map->_lock);
+#endif
     return it->second;
   }
 
@@ -148,6 +158,9 @@ Dtool_PyTypedObject *Dtool_GetSuperBase() {
 
   if (PyType_Ready((PyTypeObject *)&super_base_type) < 0) {
     PyErr_SetString(PyExc_TypeError, "PyType_Ready(Dtool_DTOOL_SUPER_BASE)");
+#ifdef Py_GIL_DISABLED
+    PyMutex_Unlock(&type_map->_lock);
+#endif
     return nullptr;
   }
   Py_INCREF(&super_base_type._PyType);
@@ -155,6 +168,9 @@ Dtool_PyTypedObject *Dtool_GetSuperBase() {
   PyDict_SetItemString(super_base_type._PyType.tp_dict, "DtoolGetSuperBase", PyCFunction_New(&methods[0], (PyObject *)&super_base_type));
 
   (*type_map)["DTOOL_SUPER_BASE"] = &super_base_type;
+#ifdef Py_GIL_DISABLED
+  PyMutex_Unlock(&type_map->_lock);
+#endif
   return &super_base_type;
 }
 

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/src/interrogatedb/py_compat.h

@@ -189,6 +189,20 @@ INLINE PyObject *_PyObject_FastCall(PyObject *func, PyObject **args, Py_ssize_t
   } while (0)
 #endif
 
+#if PY_VERSION_HEX < 0x03070000
+INLINE PyObject *PyImport_GetModule(PyObject *name) {
+  PyObject *modules = PyImport_GetModuleDict();
+  if (modules != nullptr) {
+    PyObject *module = PyDict_GetItem(modules, name);
+    if (module != nullptr) {
+      Py_INCREF(module);
+      return module;
+    }
+  }
+  return nullptr;
+}
+#endif
+
 /* Python 3.8 */
 #if PY_VERSION_HEX < 0x03080000
 INLINE PyObject *_PyLong_Rshift(PyObject *a, size_t shiftby) {
@@ -267,6 +281,18 @@ ALWAYS_INLINE PyObject *Py_XNewRef(PyObject *obj) {
 }
 #endif
 
+/* Python 3.11 */
+
+#if PY_VERSION_HEX < 0x030B0000
+INLINE PyObject *PyType_GetName(PyTypeObject *type) {
+  return PyObject_GetAttrString((PyObject *)type, "__name__");
+}
+
+INLINE PyObject *PyType_GetQualName(PyTypeObject *type) {
+  return PyObject_GetAttrString((PyObject *)type, "__qualname__");
+}
+#endif
+
 /* Python 3.12 */
 
 #if PY_VERSION_HEX < 0x030C0000
@@ -279,6 +305,77 @@ INLINE bool PyLong_IsNonNegative(PyObject *value) {
 }
 #endif
 
+/* Python 3.13 */
+
+#if PY_VERSION_HEX < 0x030D00A1
+#  define PyLong_AsInt(x) (_PyLong_AsInt(x))
+#endif
+
+#if PY_VERSION_HEX < 0x030D00A1
+ALWAYS_INLINE int
+PyModule_Add(PyObject *mod, const char *name, PyObject *value) {
+  int res = PyModule_AddObjectRef(mod, name, value);
+  Py_XDECREF(value);
+  return res;
+}
+#endif
+
+#if PY_VERSION_HEX < 0x030D00A1
+INLINE int
+PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) {
+#if PY_MAJOR_VERSION >= 3
+  PyObject *item = PyDict_GetItemWithError(mp, key);
+#else
+  PyObject *item = _PyDict_GetItemWithError(mp, key);
+#endif
+  if (item != nullptr) {
+    *result = Py_NewRef(item);
+    return 1;
+  }
+  *result = nullptr;
+  return PyErr_Occurred() ? -1 : 0;
+}
+
+INLINE int
+PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) {
+  PyObject *item = nullptr;
+#if PY_MAJOR_VERSION >= 3
+  PyObject *key_obj = PyUnicode_FromString(key);
+  item = key_obj ? PyDict_GetItemWithError(mp, key_obj) : nullptr;
+#else
+  PyObject *key_obj = PyString_FromString(key);
+  item = key_obj ? _PyDict_GetItemWithError(mp, key_obj) : nullptr;
+#endif
+  Py_DECREF(key_obj);
+  if (item != nullptr) {
+    *result = Py_NewRef(item);
+    return 1;
+  }
+  *result = nullptr;
+  return PyErr_Occurred() ? -1 : 0;
+}
+#endif
+
+#if PY_VERSION_HEX >= 0x03050200 && PY_VERSION_HEX < 0x030D00A1
+#  define PyThreadState_GetUnchecked() (_PyThreadState_UncheckedGet())
+#endif
+
+#if PY_VERSION_HEX < 0x030D00A2
+#  define PyList_Extend(list, iterable) (PyList_SetSlice((list), PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, (iterable)))
+#  define PyList_Clear(list) (PyList_SetSlice((list), 0, PY_SSIZE_T_MAX, nullptr))
+#endif
+
+#if PY_VERSION_HEX < 0x030D00A4
+#  define PyList_GetItemRef(op, index) (Py_XNewRef(PyList_GetItem((op), (index))))
+#endif
+
+#if PY_VERSION_HEX < 0x030D00B3
+#  define Py_BEGIN_CRITICAL_SECTION(op) {
+#  define Py_END_CRITICAL_SECTION() }
+#  define Py_BEGIN_CRITICAL_SECTION2(a, b) {
+#  define Py_END_CRITICAL_SECTION2() }
+#endif
+
 /* Other Python implementations */
 
 #endif  // HAVE_PYTHON

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/src/interrogatedb/py_panda.cxx

@@ -328,9 +328,9 @@ static PyObject *Dtool_EnumType_New(PyTypeObject *subtype, PyObject *args, PyObj
   PyObject *value2member = PyDict_GetItemString(subtype->tp_dict, "_value2member_map_");
   nassertr_always(value2member != nullptr, nullptr);
 
-  PyObject *member = PyDict_GetItem(value2member, arg);
-  if (member != nullptr) {
-    return Py_NewRef(member);
+  PyObject *member;
+  if (PyDict_GetItemRef(value2member, arg, &member) > 0) {
+    return member;
   }
 
   PyObject *repr = PyObject_Repr(arg);
@@ -375,23 +375,26 @@ static PyObject *Dtool_EnumType_Repr(PyObject *self) {
  * should be a tuple of (name, value) pairs.
  */
 PyTypeObject *Dtool_EnumType_Create(const char *name, PyObject *names, const char *module) {
-  static PyObject *enum_class = nullptr;
 #if PY_VERSION_HEX >= 0x03040000
-  static PyObject *enum_meta = nullptr;
-  static PyObject *enum_create = nullptr;
-  if (enum_meta == nullptr) {
-    PyObject *enum_module = PyImport_ImportModule("enum");
-    nassertr_always(enum_module != nullptr, nullptr);
+  PyObject *enum_module = PyImport_ImportModule("enum");
+  nassertr_always(enum_module != nullptr, nullptr);
 
-    enum_class = PyObject_GetAttrString(enum_module, "Enum");
-    enum_meta = PyObject_GetAttrString(enum_module, "EnumMeta");
-    enum_create = PyObject_GetAttrString(enum_meta, "_create_");
-    nassertr(enum_meta != nullptr, nullptr);
-  }
+  PyObject *enum_meta = PyObject_GetAttrString(enum_module, "EnumMeta");
+  nassertr(enum_meta != nullptr, nullptr);
+
+  PyObject *enum_class = PyObject_GetAttrString(enum_module, "Enum");
+  Py_DECREF(enum_module);
+  nassertr(enum_class != nullptr, nullptr);
+
+  PyObject *enum_create = PyObject_GetAttrString(enum_meta, "_create_");
+  Py_DECREF(enum_meta);
 
   PyObject *result = PyObject_CallFunction(enum_create, (char *)"OsN", enum_class, name, names);
+  Py_DECREF(enum_create);
+  Py_DECREF(enum_class);
   nassertr(result != nullptr, nullptr);
 #else
+  static PyObject *enum_class = nullptr;
   static PyObject *name_str;
   static PyObject *name_sunder_str;
   static PyObject *value_str;
@@ -528,16 +531,39 @@ PyObject *DTool_CreatePyInstance(void *local_this, Dtool_PyTypedObject &in_class
  * Returns a borrowed reference to the global type dictionary.
  */
 Dtool_TypeMap *Dtool_GetGlobalTypeMap() {
+#if PY_VERSION_HEX >= 0x030d0000 // 3.13
+  PyObject *istate_dict = PyInterpreterState_GetDict(PyInterpreterState_Get());
+  PyObject *key = PyUnicode_InternFromString("_interrogate_types");
+  PyObject *capsule = PyDict_GetItem(istate_dict, key);
+  if (capsule != nullptr) {
+    Py_DECREF(key);
+    return (Dtool_TypeMap *)PyCapsule_GetPointer(capsule, nullptr);
+  }
+#else
   PyObject *capsule = PySys_GetObject((char *)"_interrogate_types");
   if (capsule != nullptr) {
     return (Dtool_TypeMap *)PyCapsule_GetPointer(capsule, nullptr);
-  } else {
-    Dtool_TypeMap *type_map = new Dtool_TypeMap;
-    capsule = PyCapsule_New((void *)type_map, nullptr, nullptr);
-    PySys_SetObject((char *)"_interrogate_types", capsule);
+  }
+#endif
+
+  Dtool_TypeMap *type_map = new Dtool_TypeMap;
+  capsule = PyCapsule_New((void *)type_map, nullptr, nullptr);
+
+#if PY_VERSION_HEX >= 0x030d0000 // 3.13
+  PyObject *result;
+  if (PyDict_SetDefaultRef(istate_dict, key, capsule, &result) != 0) {
+    // Another thread already beat us to it.
     Py_DECREF(capsule);
-    return type_map;
+    delete type_map;
+    capsule = result;
+    type_map = (Dtool_TypeMap *)PyCapsule_GetPointer(capsule, nullptr);
   }
+  Py_DECREF(key);
+#endif
+
+  PySys_SetObject((char *)"_interrogate_types", capsule);
+  Py_DECREF(capsule);
+  return type_map;
 }
 
 /**
@@ -594,6 +620,10 @@ PyObject *Dtool_PyModuleInitHelper(const LibraryDef *defs[], const char *modulen
 
   Dtool_TypeMap *type_map = Dtool_GetGlobalTypeMap();
 
+#ifdef Py_GIL_DISABLED
+  PyMutex_Lock(&type_map->_lock);
+#endif
+
   // the module level function inits....
   MethodDefmap functions;
   for (size_t i = 0; defs[i] != nullptr; i++) {
@@ -627,12 +657,19 @@ PyObject *Dtool_PyModuleInitHelper(const LibraryDef *defs[], const char *modulen
         if (it != type_map->end()) {
           types->type = it->second;
         } else {
-          return PyErr_Format(PyExc_NameError, "name '%s' is not defined", types->name);
+          PyErr_Format(PyExc_NameError, "name '%s' is not defined", types->name);
+#ifdef Py_GIL_DISABLED
+          PyMutex_Unlock(&type_map->_lock);
+#endif
+          return nullptr;
         }
         ++types;
       }
     }
   }
+#ifdef Py_GIL_DISABLED
+  PyMutex_Unlock(&type_map->_lock);
+#endif
 
   PyMethodDef *newdef = new PyMethodDef[functions.size() + 1];
   MethodDefmap::iterator mi;
@@ -886,7 +923,9 @@ bool Dtool_ExtractOptionalArg(PyObject **result, PyObject *args, PyObject *kwds,
       }
 
       // We got the item, we just need to make sure that it had the right key.
-#if PY_VERSION_HEX >= 0x03060000
+#if PY_VERSION_HEX >= 0x030d0000
+      return PyUnicode_CheckExact(key) && PyUnicode_EqualToUTF8(key, keyword);
+#elif PY_VERSION_HEX >= 0x03060000
       return PyUnicode_CheckExact(key) && _PyUnicode_EqualToASCIIString(key, keyword);
 #elif PY_MAJOR_VERSION >= 3
       return PyUnicode_CheckExact(key) && PyUnicode_CompareWithASCIIString(key, keyword) == 0;

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/src/interrogatedb/py_panda.h

@@ -174,7 +174,14 @@ static void Dtool_FreeInstance_##CLASS_NAME(PyObject *self) {\
 // forward declared of typed object.  We rely on the fact that typed objects
 // are uniquly defined by an integer.
 
+#if PY_VERSION_HEX >= 0x030d0000
+class Dtool_TypeMap : public std::map<std::string, Dtool_PyTypedObject *> {
+public:
+  PyMutex _lock { 0 };
+};
+#else
 typedef std::map<std::string, Dtool_PyTypedObject *> Dtool_TypeMap;
+#endif
 
 EXPCL_PYPANDA Dtool_TypeMap *Dtool_GetGlobalTypeMap();
 

{panda3d_interrogate-0.1.0 → panda3d_interrogate-0.2.0}/src/interrogatedb/py_wrappers.cxx

@@ -17,25 +17,33 @@
 #endif
 
 static void _register_collection(PyTypeObject *type, const char *abc) {
-  PyObject *sys_modules = PyImport_GetModuleDict();
-  if (sys_modules != nullptr) {
-    PyObject *module = PyDict_GetItemString(sys_modules, _COLLECTIONS_ABC);
-    if (module != nullptr) {
-      PyObject *dict = PyModule_GetDict(module);
-      if (module != nullptr) {
 #if PY_MAJOR_VERSION >= 3
-        static PyObject *register_str = PyUnicode_InternFromString("register");
+  PyObject *module_name = PyUnicode_InternFromString(_COLLECTIONS_ABC);
 #else
-        static PyObject *register_str = PyString_InternFromString("register");
+  PyObject *module_name = PyString_InternFromString(_COLLECTIONS_ABC);
 #endif
-        PyObject *sequence = PyDict_GetItemString(dict, abc);
-        if (sequence != nullptr) {
-          if (PyObject_CallMethodOneArg(sequence, register_str, (PyObject *)type) == nullptr) {
-            PyErr_Print();
-          }
-        }
+  PyObject *module = PyImport_GetModule(module_name);
+  Py_DECREF(module_name);
+  if (module != nullptr) {
+    PyObject *dict = PyModule_GetDict(module);
+    if (dict != nullptr) {
+#if PY_MAJOR_VERSION >= 3
+      PyObject *register_str = PyUnicode_InternFromString("register");
+#else
+      PyObject *register_str = PyString_InternFromString("register");
+#endif
+      PyObject *obj = nullptr;
+      if (register_str == nullptr ||
+          PyDict_GetItemStringRef(dict, abc, &obj) <= 0 ||
+          PyObject_CallMethodOneArg(obj, register_str, (PyObject *)type) == nullptr) {
+        PyErr_Print();
       }
+      Py_XDECREF(obj);
+      Py_XDECREF(register_str);
+    } else {
+      PyErr_Clear();
     }
+    Py_DECREF(module);
   }
 }
 
@@ -1075,14 +1083,19 @@ static PyObject *Dtool_MutableMappingWrapper_update(PyObject *self, PyObject *ar
     return PyErr_Format(PyExc_TypeError, "%s.update() takes either a dict argument or keyword arguments", wrap->_base._name);
   }
 
+  PyObject *result = Py_None;
   PyObject *key, *value;
   Py_ssize_t pos = 0;
+  Py_BEGIN_CRITICAL_SECTION(dict);
   while (PyDict_Next(dict, &pos, &key, &value)) {
     if (wrap->_setitem_func(wrap->_base._self, key, value) != 0) {
-      return nullptr;
+      result = nullptr;
+      break;
     }
   }
-  return Py_NewRef(Py_None);
+  Py_END_CRITICAL_SECTION();
+
+  return Py_XNewRef(result);
 }
 
 /**