Prevent crashes when creating objects during interpreter shutdown

(The crashes happen only since Python 3.13)

In particular:

* Skip adding to the weak map if `Py_IsFinalizing()` is true. Calling `PyUpb_WeakMap_Add` may be caused by user code that creates protos inside `__del__`!

* `PyUpb_DescriptorPool_Get` and subsequently `PyUpb_ObjCache_Get` may *also* be called if users cause `PyUpb_RepeatedContainer_GetOrCreateWrapper` to be called. So make it nullable and skip the assertion if currently shutting down.

This follows a prior attempted fix d57d270 but expands the scope of it.

PiperOrigin-RevId: 856589514

Author: oprypin

python/descriptor_pool.c

@@ -12,6 +12,7 @@
 #include "python/descriptor.h"
 #include "python/message.h"
 #include "python/protobuf.h"
+#include "python/python_api.h"
 #include "upb/base/upcast.h"
 #include "upb/message/compare.h"
 #include "upb/reflection/def.h"
@@ -75,7 +76,11 @@ static int PyUpb_DescriptorPool_Clear(PyUpb_DescriptorPool* self) {
 
 PyObject* PyUpb_DescriptorPool_Get(const upb_DefPool* symtab) {
   PyObject* pool = PyUpb_ObjCache_Get(symtab);
-  assert(pool);
+  assert(pool
+#if PY_VERSION_HEX >= 0x030D0000  // >= 3.13
+         || Py_IsFinalizing()
+#endif
+  );
   return pool;
 }
 

python/protobuf.c

@@ -180,24 +180,58 @@ PyUpb_WeakMap* PyUpb_ObjCache_Instance(void) {
   return state->obj_cache;
 }
 
+static PyUpb_WeakMap* PyUpb_ObjCache_MaybeInstance(void) {
+  // During the shutdown sequence, our objects may need to be deallocated, or
+  // there may even still be attempts to *construct* new ones (in user code).
+  // At that point our state will be NULL, so all access to the cache has to be
+  // no-op.
+  PyUpb_ModuleState* state = PyUpb_ModuleState_MaybeGet();
+  if (!state) {
+    return NULL;
+  }
+  return state->obj_cache;
+}
+
 void PyUpb_ObjCache_Add(const void* key, PyObject* py_obj) {
-  PyUpb_WeakMap_Add(PyUpb_ObjCache_Instance(), key, py_obj);
+  PyUpb_WeakMap* cache = PyUpb_ObjCache_MaybeInstance();
+  if (!cache) {
+    return;
+  }
+  PyUpb_WeakMap_Add(cache, key, py_obj);
 }
 
 void PyUpb_ObjCache_Delete(const void* key) {
-  PyUpb_ModuleState* state = PyUpb_ModuleState_MaybeGet();
-  if (!state) {
-    // During the shutdown sequence, our object's Dealloc() methods can be
-    // called *after* our module Dealloc() method has been called.  At that
-    // point our state will be NULL and there is nothing to delete out of the
-    // map.
+  PyUpb_WeakMap* cache = PyUpb_ObjCache_MaybeInstance();
+  if (!cache) {
     return;
   }
-  PyUpb_WeakMap_Delete(state->obj_cache, key);
+  PyUpb_WeakMap_Delete(cache, key);
 }
 
 PyObject* PyUpb_ObjCache_Get(const void* key) {
-  return PyUpb_WeakMap_Get(PyUpb_ObjCache_Instance(), key);
+  PyUpb_WeakMap* cache = PyUpb_ObjCache_MaybeInstance();
+  if (!cache) {
+    // When the interpreter is finalizing, the state may not be available, so
+    // we don't try to find existing objects in the object cache - in order to
+    // prevent a crash. Unfortunately, doing this can lead to different
+    // semantics in protobuf APIs during shutdown. For example:
+    //
+    //   m = MyMessage()
+    //
+    //   # Returns true most of the time, but false during shutdown.
+    //   assert(m.submsg is m.submsg)
+    //   assert(Py_IsFinalizing());
+    //
+    //
+    //   # Returns true most of the time, but false during shutdown.
+    //   assert(foo_pb2.DESCRIPTOR.message_types_by_name['Bar'] is
+    //          foo_pb2.DESCRIPTOR.message_types_by_name['Bar')
+#if PY_VERSION_HEX >= 0x030D0000  // >= 3.13
+    assert(Py_IsFinalizing());
+#endif
+    return NULL;
+  }
+  return PyUpb_WeakMap_Get(cache, key);
 }
 
 // -----------------------------------------------------------------------------