WIP.

python/BUILD

@@ -43,6 +43,8 @@ cc_binary(
         "descriptor_containers.h",
         "descriptor_pool.c",
         "descriptor_pool.h",
+        "message.c",
+        "message.h",
         "protobuf.c",
         "protobuf.h",
         "python.h",
@@ -63,9 +65,11 @@ cc_binary(
     deps = [
         ":version_script.lds",
         "//:reflection",
+        "//:textformat",
         "//:upb",
         "//upb/util:compare",
         "//upb/util:def_to_proto",
+        "//upb/util:required_fields",
         "@system_python//:python_headers",
     ],
 )

python/message.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2009-2021, Google LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Google LLC nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PYPB_MESSAGE_H__
+#define PYPB_MESSAGE_H__
+
+#include <stdbool.h>
+
+#include "python/protobuf.h"
+#include "upb/reflection.h"
+
+PyObject* PyUpb_MessageMeta_CreateClass(PyObject* py_descriptor);
+void PyUpb_CMessage_CacheDelete(PyObject* _self, const upb_fielddef* f);
+void PyUpb_CMessage_SetConcreteSubobj(PyObject* _self, const upb_fielddef* f,
+                                      upb_msgval subobj);
+PyObject* PyUpb_CMessage_Get(upb_msg* u_msg, const upb_msgdef* m,
+                             PyObject* arena);
+bool PyUpb_CMessage_Check(PyObject* self);
+upb_msg* PyUpb_CMessage_GetIfWritable(PyObject* _self);
+const upb_msgdef* PyUpb_CMessage_GetMsgdef(PyObject* self);
+PyObject* PyUpb_CMessage_MergeFrom(PyObject* self, PyObject* arg);
+PyObject* PyUpb_CMessage_MergeFromString(PyObject* self, PyObject* arg);
+PyObject* PyUpb_CMessage_SerializeToString(PyObject* self, PyObject* args,
+                                           PyObject* kwargs);
+int PyUpb_CMessage_InitAttributes(PyObject* _self, PyObject* args,
+                                  PyObject* kwargs);
+void PyUpb_CMessage_ClearExtensionDict(PyObject* _self);
+PyObject* PyUpb_CMessage_GetFieldValue(PyObject* _self,
+                                       const upb_fielddef* field);
+int PyUpb_CMessage_SetFieldValue(PyObject* _self, const upb_fielddef* field,
+                                 PyObject* value);
+int PyUpb_CMessage_GetVersion(PyObject* _self);
+
+bool PyUpb_InitMessage(PyObject* m);
+
+#endif  // PYPB_MESSAGE_H__

python/protobuf.c

@@ -68,6 +68,25 @@ PyUpb_ModuleState *PyUpb_ModuleState_Get(void) {
   return PyUpb_ModuleState_GetFromModule(module);
 }
 
+PyObject *PyUpb_GetWktBases(PyUpb_ModuleState *state) {
+  if (!state->wkt_bases) {
+    PyObject *wkt_module =
+        PyImport_ImportModule("google.protobuf.internal.well_known_types");
+
+    if (wkt_module == NULL) {
+      return false;
+    }
+
+    state->wkt_bases = PyObject_GetAttrString(wkt_module, "WKTBASES");
+    PyObject *m = PyState_FindModule(&module_def);
+    // Make sure it is GC'd.
+    PyModule_AddObject(m, "__internal_wktbases", state->wkt_bases);
+    Py_DECREF(wkt_module);
+  }
+
+  return state->wkt_bases;
+}
+
 // -----------------------------------------------------------------------------
 // ObjectCache
 // -----------------------------------------------------------------------------

python/protobuf.h

@@ -61,10 +61,20 @@ typedef struct {
   // From descriptor_pool.c
   PyTypeObject *descriptor_pool_type;
 
+  // From message.c
+  PyObject *decode_error_class;
+  PyObject* descriptor_string;
+  PyObject *encode_error_class;
+  PyObject *enum_type_wrapper_class;
+  PyObject *message_class;
+  PyTypeObject *cmessage_type;
+  PyTypeObject *message_meta_type;
+
   // From protobuf.c
+  PyObject *wkt_bases;
+  PyTypeObject *arena_type;
   upb_arena *obj_cache_arena;
   upb_inttable obj_cache;
-  PyTypeObject *arena_type;
 } PyUpb_ModuleState;
 
 // Returns the global state object from the current interpreter. The current
@@ -72,18 +82,58 @@ typedef struct {
 PyUpb_ModuleState *PyUpb_ModuleState_Get(void);
 PyUpb_ModuleState *PyUpb_ModuleState_GetFromModule(PyObject *module);
 
+// Returns NULL if module state is not yet available (during startup).
+// Any use of the module state during startup needs to be passed explicitly.
+PyUpb_ModuleState* PyUpb_ModuleState_MaybeGet(void);
+
+// Returns:
+//   from google.protobuf.internal.well_known_types import WKTBASES
+//
+// This has to be imported lazily rather than at module load time, because
+// otherwise it would cause a circular import.
+PyObject *PyUpb_GetWktBases(PyUpb_ModuleState *state);
+
 // -----------------------------------------------------------------------------
-// ObjectCache
+// WeakMap
 // -----------------------------------------------------------------------------
 
-// The ObjectCache is a weak map that maps C pointers to the corresponding
+// A WeakMap maps C pointers to the corresponding Python wrapper object. We
-// Python wrapper object. We want a consistent Python wrapper object for each
+// want a consistent Python wrapper object for each C object, both to save
-// C object, both to save memory and to provide object stability (ie. x is x).
+// memory and to provide object stability (ie. x is x).
 //
 // Each wrapped object should add itself to the map when it is constructed and
 // remove itself from the map when it is destroyed. The map is weak so it does
 // not take references to the cached objects.
 
+struct PyUpb_WeakMap;
+typedef struct PyUpb_WeakMap PyUpb_WeakMap;
+
+PyUpb_WeakMap *PyUpb_WeakMap_New(void);
+void PyUpb_WeakMap_Free(PyUpb_WeakMap *map);
+
+// Adds the given object to the map, indexed by the given key.
+void PyUpb_WeakMap_Add(PyUpb_WeakMap *map, const void *key, PyObject *py_obj);
+
+// Removes the given key from the cache. It must exist in the cache currently.
+void PyUpb_WeakMap_Delete(PyUpb_WeakMap *map, const void *key);
+void PyUpb_WeakMap_TryDelete(PyUpb_WeakMap *map, const void *key);
+
+// Returns a new reference to an object if it exists, otherwise returns NULL.
+PyObject *PyUpb_WeakMap_Get(PyUpb_WeakMap *map, const void *key);
+
+#define PYUPB_WEAKMAP_BEGIN UPB_INTTABLE_BEGIN
+
+bool PyUpb_WeakMap_Next(PyUpb_WeakMap *map, const void **key, PyObject **obj,
+                        intptr_t *iter);
+void PyUpb_WeakMap_DeleteIter(PyUpb_WeakMap *map, intptr_t *iter);
+
+// -----------------------------------------------------------------------------
+// ObjectCache
+// -----------------------------------------------------------------------------
+
+// The object cache is a global WeakMap for mapping upb objects to the
+// corresponding wrapper.
+
 // Adds the given object to the cache, indexed by the given key.
 void PyUpb_ObjCache_Add(const void *key, PyObject *py_obj);