diff --git a/pybind11_protobuf/BUILD b/pybind11_protobuf/BUILD
index f34fab0..b259ef8 100644
--- a/pybind11_protobuf/BUILD
+++ b/pybind11_protobuf/BUILD
@@ -11,7 +11,7 @@ pybind_library(
         "//visibility:public",
     ],
     deps = [
-        "@com_google_protobuf//:protobuf",
+        "//third_party/protobuf:protobuf_lite",
     ],
 )
 
@@ -39,6 +39,7 @@ pybind_library(
     ],
     deps = [
         ":check_unknown_fields",
+        "//third_party/protobuf:descriptor_pb",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/log",
         "@com_google_absl//absl/log:check",
@@ -71,7 +72,6 @@ cc_library(
     deps = [
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
-        "@com_google_absl//absl/meta:type_traits",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
         "@com_google_protobuf//:protobuf",
diff --git a/pybind11_protobuf/check_unknown_fields.cc b/pybind11_protobuf/check_unknown_fields.cc
index 0639d09..9e50923 100644
--- a/pybind11_protobuf/check_unknown_fields.cc
+++ b/pybind11_protobuf/check_unknown_fields.cc
@@ -6,22 +6,23 @@
 #include <string>
 #include <vector>
 
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/message.h"
-#include "google/protobuf/unknown_field_set.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "absl/synchronization/mutex.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
+#include "google/protobuf/unknown_field_set.h"
+#include "python/google/protobuf/proto_api.h"
 
 namespace pybind11_protobuf::check_unknown_fields {
 namespace {
 
 using AllowListSet = absl::flat_hash_set<std::string>;
 using MayContainExtensionsMap =
-    absl::flat_hash_map<const ::google::protobuf::Descriptor*, bool>;
+    absl::flat_hash_map<const google::protobuf::Descriptor*, bool>;
 
 AllowListSet* GetAllowList() {
   static auto* allow_list = new AllowListSet();
@@ -37,7 +38,7 @@ std::string MakeAllowListKey(
 
 /// Recurses through the message Descriptor class looking for valid extensions.
 /// Stores the result to `memoized`.
-bool MessageMayContainExtensionsRecursive(const ::google::protobuf::Descriptor* descriptor,
+bool MessageMayContainExtensionsRecursive(const google::protobuf::Descriptor* descriptor,
                                           MayContainExtensionsMap* memoized) {
   if (descriptor->extension_range_count() > 0) return true;
 
@@ -48,7 +49,7 @@ bool MessageMayContainExtensionsRecursive(const ::google::protobuf::Descriptor*
 
   for (int i = 0; i < descriptor->field_count(); i++) {
     auto* fd = descriptor->field(i);
-    if (fd->cpp_type() != ::google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) continue;
+    if (fd->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) continue;
     if (MessageMayContainExtensionsRecursive(fd->message_type(), memoized)) {
       (*memoized)[descriptor] = true;
       return true;
@@ -58,7 +59,7 @@ bool MessageMayContainExtensionsRecursive(const ::google::protobuf::Descriptor*
   return false;
 }
 
-bool MessageMayContainExtensionsMemoized(const ::google::protobuf::Descriptor* descriptor) {
+bool MessageMayContainExtensionsMemoized(const google::protobuf::Descriptor* descriptor) {
   static auto* memoized = new MayContainExtensionsMap();
   static absl::Mutex lock;
   absl::MutexLock l(&lock);
@@ -66,8 +67,8 @@ bool MessageMayContainExtensionsMemoized(const ::google::protobuf::Descriptor* d
 }
 
 struct HasUnknownFields {
-  HasUnknownFields(const ::google::protobuf::python::PyProto_API* py_proto_api,
-                   const ::google::protobuf::Descriptor* root_descriptor)
+  HasUnknownFields(const google::protobuf::python::PyProto_API* py_proto_api,
+                   const google::protobuf::Descriptor* root_descriptor)
       : py_proto_api(py_proto_api), root_descriptor(root_descriptor) {}
 
   std::string FieldFQN() const { return absl::StrJoin(field_fqn_parts, "."); }
@@ -77,25 +78,25 @@ struct HasUnknownFields {
                : absl::StrCat(FieldFQN(), ".", unknown_field_number);
   }
 
-  bool FindUnknownFieldsRecursive(const ::google::protobuf::Message* sub_message,
+  bool FindUnknownFieldsRecursive(const google::protobuf::Message* sub_message,
                                   uint32_t depth);
 
   std::string BuildErrorMessage() const;
 
-  const ::google::protobuf::python::PyProto_API* py_proto_api;
-  const ::google::protobuf::Descriptor* root_descriptor = nullptr;
-  const ::google::protobuf::Descriptor* unknown_field_parent_descriptor = nullptr;
+  const google::protobuf::python::PyProto_API* py_proto_api;
+  const google::protobuf::Descriptor* root_descriptor = nullptr;
+  const google::protobuf::Descriptor* unknown_field_parent_descriptor = nullptr;
   std::vector<std::string> field_fqn_parts;
   int unknown_field_number;
 };
 
 /// Recurses through the message fields class looking for UnknownFields.
 bool HasUnknownFields::FindUnknownFieldsRecursive(
-    const ::google::protobuf::Message* sub_message, uint32_t depth) {
-  const ::google::protobuf::Reflection& reflection = *sub_message->GetReflection();
+    const google::protobuf::Message* sub_message, uint32_t depth) {
+  const google::protobuf::Reflection& reflection = *sub_message->GetReflection();
 
   // If there are unknown fields, stop searching.
-  const ::google::protobuf::UnknownFieldSet& unknown_field_set =
+  const google::protobuf::UnknownFieldSet& unknown_field_set =
       reflection.GetUnknownFields(*sub_message);
   if (!unknown_field_set.empty()) {
     unknown_field_parent_descriptor = sub_message->GetDescriptor();
@@ -103,8 +104,7 @@ bool HasUnknownFields::FindUnknownFieldsRecursive(
 
     // Stop only if the extension is known by Python.
     if (py_proto_api->GetDefaultDescriptorPool()->FindExtensionByNumber(
-            unknown_field_parent_descriptor,
-            unknown_field_number)) {
+            unknown_field_parent_descriptor, unknown_field_number)) {
       field_fqn_parts.resize(depth);
       return true;
     }
@@ -118,11 +118,11 @@ bool HasUnknownFields::FindUnknownFieldsRecursive(
 
   // Otherwise the method has to check all present fields, including
   // extensions to determine if they include unknown fields.
-  std::vector<const ::google::protobuf::FieldDescriptor*> present_fields;
+  std::vector<const google::protobuf::FieldDescriptor*> present_fields;
   reflection.ListFields(*sub_message, &present_fields);
 
   for (const auto* field : present_fields) {
-    if (field->cpp_type() != ::google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
+    if (field->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
       continue;
     }
     if (field->is_repeated()) {
@@ -182,8 +182,8 @@ void AllowUnknownFieldsFor(absl::string_view top_message_descriptor_full_name,
 }
 
 std::optional<std::string> CheckRecursively(
-    const ::google::protobuf::python::PyProto_API* py_proto_api,
-    const ::google::protobuf::Message* message) {
+    const google::protobuf::python::PyProto_API* py_proto_api,
+    const google::protobuf::Message* message) {
   const auto* root_descriptor = message->GetDescriptor();
   HasUnknownFields search{py_proto_api, root_descriptor};
   if (!search.FindUnknownFieldsRecursive(message, 0u)) {
diff --git a/pybind11_protobuf/check_unknown_fields.h b/pybind11_protobuf/check_unknown_fields.h
index 79ac001..b25b89f 100644
--- a/pybind11_protobuf/check_unknown_fields.h
+++ b/pybind11_protobuf/check_unknown_fields.h
@@ -2,10 +2,11 @@
 #define PYBIND11_PROTOBUF_CHECK_UNKNOWN_FIELDS_H_
 
 #include <optional>
+#include <string>
 
+#include "absl/strings/string_view.h"
 #include "google/protobuf/message.h"
 #include "python/google/protobuf/proto_api.h"
-#include "absl/strings/string_view.h"
 
 namespace pybind11_protobuf::check_unknown_fields {
 
@@ -46,8 +47,8 @@ void AllowUnknownFieldsFor(absl::string_view top_message_descriptor_full_name,
                            absl::string_view unknown_field_parent_message_fqn);
 
 std::optional<std::string> CheckRecursively(
-    const ::google::protobuf::python::PyProto_API* py_proto_api,
-    const ::google::protobuf::Message* top_message);
+    const google::protobuf::python::PyProto_API* py_proto_api,
+    const google::protobuf::Message* top_message);
 
 }  // namespace pybind11_protobuf::check_unknown_fields
 
diff --git a/pybind11_protobuf/enum_type_caster.h b/pybind11_protobuf/enum_type_caster.h
index d30369b..9f7f94a 100644
--- a/pybind11_protobuf/enum_type_caster.h
+++ b/pybind11_protobuf/enum_type_caster.h
@@ -11,21 +11,19 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/pytypes.h>
 
-#include <string>
 #include <type_traits>
 
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/generated_enum_reflection.h"
 #include "google/protobuf/generated_enum_util.h"
 
 // pybind11 type_caster specialization which translates Proto::Enum types
 // to/from ints. This will have ODR conflicts when users specify wrappers for
 // enums using py::enum_<T>.
 //
-// ::google::protobuf::is_proto_enum and ::google::protobuf::GetEnumDescriptor are require
+// google::protobuf::is_proto_enum and google::protobuf::GetEnumDescriptor
+// are require
 //
-// NOTE: The protobuf compiler does not generate ::google::protobuf::is_proto_enum traits
-// for enumerations of oneof fields.
+// NOTE: The protobuf compiler does not generate
+// google::protobuf::is_proto_enum traits for enumerations of oneof fields.
 //
 // Example:
 //  #include <pybind11/pybind11.h>
@@ -100,17 +98,17 @@ constexpr bool pybind11_protobuf_enable_enum_type_caster(...) { return true; }
 #if defined(PYBIND11_HAS_NATIVE_ENUM)
 template <typename EnumType>
 struct type_caster_enum_type_enabled<
-    EnumType, std::enable_if_t<(::google::protobuf::is_proto_enum<EnumType>::value &&
+    EnumType, std::enable_if_t<(google::protobuf::is_proto_enum<EnumType>::value &&
                                 pybind11_protobuf_enable_enum_type_caster(
                                     static_cast<EnumType*>(nullptr)))>>
     : std::false_type {};
 #endif
 
 // Specialization of pybind11::detail::type_caster<T> for types satisfying
-// ::google::protobuf::is_proto_enum.
+// google::protobuf::is_proto_enum.
 template <typename EnumType>
 struct type_caster<EnumType,
-                   std::enable_if_t<(::google::protobuf::is_proto_enum<EnumType>::value &&
+                   std::enable_if_t<(google::protobuf::is_proto_enum<EnumType>::value &&
                                      pybind11_protobuf_enable_enum_type_caster(
                                          static_cast<EnumType*>(nullptr)))>>
     : public pybind11_protobuf::enum_type_caster<EnumType> {};
diff --git a/pybind11_protobuf/native_proto_caster.h b/pybind11_protobuf/native_proto_caster.h
index 6d020e0..cd64f4a 100644
--- a/pybind11_protobuf/native_proto_caster.h
+++ b/pybind11_protobuf/native_proto_caster.h
@@ -11,22 +11,17 @@
 // IWYU
 #include <Python.h>
 
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
 #include <type_traits>
-#include <utility>
 
-#include "google/protobuf/message.h"
 #include "absl/strings/string_view.h"
+#include "google/protobuf/message.h"
 #include "pybind11_protobuf/enum_type_caster.h"
 #include "pybind11_protobuf/proto_caster_impl.h"
 
-// pybind11::type_caster<> specialization for ::google::protobuf::Message types that
-// that converts protocol buffer objects between C++ and python representations.
-// This binder supports binaries linked with both native python protos
-// and fast cpp python protos.
+// pybind11::type_caster<> specialization for google::protobuf::Message types
+// that that converts protocol buffer objects between C++ and python
+// representations. This binder supports binaries linked with both native python
+// protos and fast cpp python protos.
 //
 // When passing protos between python and C++, if possible, an underlying C++
 // object may have ownership transferred, or may be copied if both instances
@@ -85,7 +80,7 @@ constexpr bool pybind11_protobuf_enable_type_caster(...) { return true; }
 template <typename ProtoType>
 struct type_caster<
     ProtoType,
-    std::enable_if_t<(std::is_base_of<::google::protobuf::Message, ProtoType>::value &&
+    std::enable_if_t<(std::is_base_of<google::protobuf::Message, ProtoType>::value &&
                       pybind11_protobuf_enable_type_caster(
                           static_cast<ProtoType *>(nullptr)))>>
     : public pybind11_protobuf::proto_caster<
@@ -95,12 +90,12 @@ struct type_caster<
 
 template <typename ProtoType>
 struct copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled<
-    ProtoType, enable_if_t<std::is_base_of<::google::protobuf::Message, ProtoType>::value>>
+    ProtoType, enable_if_t<std::is_base_of<google::protobuf::Message, ProtoType>::value>>
     : std::false_type {};
 
 template <typename ProtoType>
 struct move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled<
-    ProtoType, enable_if_t<std::is_base_of<::google::protobuf::Message, ProtoType>::value>>
+    ProtoType, enable_if_t<std::is_base_of<google::protobuf::Message, ProtoType>::value>>
     : std::false_type {};
 
 #endif  // PYBIND11_HAS_INTERNALS_WITH_SMART_HOLDER_SUPPORT
@@ -118,7 +113,7 @@ struct move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled<
 template <typename ProtoType, typename HolderType>
 struct move_only_holder_caster<
     ProtoType, HolderType,
-    std::enable_if_t<(std::is_base_of<::google::protobuf::Message, ProtoType>::value &&
+    std::enable_if_t<(std::is_base_of<google::protobuf::Message, ProtoType>::value &&
                       pybind11_protobuf_enable_type_caster(
                           static_cast<ProtoType *>(nullptr)))>>
     : public pybind11_protobuf::move_only_holder_caster_impl<ProtoType,
@@ -136,7 +131,7 @@ struct move_only_holder_caster<
 template <typename ProtoType, typename HolderType>
 struct copyable_holder_caster<
     ProtoType, HolderType,
-    std::enable_if_t<(std::is_base_of<::google::protobuf::Message, ProtoType>::value &&
+    std::enable_if_t<(std::is_base_of<google::protobuf::Message, ProtoType>::value &&
                       pybind11_protobuf_enable_type_caster(
                           static_cast<ProtoType *>(nullptr)))>>
     : public pybind11_protobuf::copyable_holder_caster_impl<ProtoType,
@@ -144,10 +139,10 @@ struct copyable_holder_caster<
 
 // NOTE: We also need to add support and/or test classes:
 //
-//  ::google::protobuf::Descriptor
-//  ::google::protobuf::EnumDescriptor
-//  ::google::protobuf::EnumValueDescriptor
-//  ::google::protobuf::FieldDescriptor
+//  google::protobuf::Descriptor
+//  google::protobuf::EnumDescriptor
+//  google::protobuf::EnumValueDescriptor
+//  google::protobuf::FieldDescriptor
 //
 
 }  // namespace detail
diff --git a/pybind11_protobuf/proto_cast_util.cc b/pybind11_protobuf/proto_cast_util.cc
index c2acac9..4593cb8 100644
--- a/pybind11_protobuf/proto_cast_util.cc
+++ b/pybind11_protobuf/proto_cast_util.cc
@@ -11,9 +11,7 @@
 #include <string>
 #include <unordered_set>
 #include <utility>
-#include <vector>
 
-#include "google/protobuf/descriptor.pb.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
@@ -25,6 +23,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 #include "google/protobuf/descriptor.h"
+#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/descriptor_database.h"
 #include "google/protobuf/dynamic_message.h"
 
@@ -34,7 +33,6 @@ using ::google::protobuf::Descriptor;
 using ::google::protobuf::DescriptorDatabase;
 using ::google::protobuf::DescriptorPool;
 using ::google::protobuf::DynamicMessageFactory;
-using ::google::protobuf::FileDescriptor;
 using ::google::protobuf::FileDescriptorProto;
 using ::google::protobuf::Message;
 using ::google::protobuf::MessageFactory;
@@ -183,11 +181,9 @@ GlobalState::GlobalState() {
 
   // pybind11_protobuf casting needs a dependency on proto internals to work.
   try {
-    ImportCached("google.protobuf.descriptor");
-    auto descriptor_pool =
-        ImportCached("google.protobuf.descriptor_pool");
-    auto message_factory =
-        ImportCached("google.protobuf.message_factory");
+    ImportCached("google.protobuf");
+    auto descriptor_pool = ImportCached("google.protobuf.descriptor_pool");
+    auto message_factory = ImportCached("google.protobuf.message_factory");
     global_pool_ = descriptor_pool.attr("Default")();
     find_message_type_by_name_ = global_pool_.attr("FindMessageTypeByName");
     if (hasattr(message_factory, "GetMessageClass")) {
@@ -221,6 +217,7 @@ py::module_ GlobalState::ImportCached(const std::string& module_name) {
   if (cached != import_cache_.end()) {
     return cached->second;
   }
+  LOG(INFO) << "ImportCached " << module_name;
   auto module = py::module_::import(module_name.c_str());
   import_cache_[module_name] = module;
   return module;
diff --git a/pybind11_protobuf/proto_cast_util.h b/pybind11_protobuf/proto_cast_util.h
index f2ff440..52de848 100644
--- a/pybind11_protobuf/proto_cast_util.h
+++ b/pybind11_protobuf/proto_cast_util.h
@@ -6,16 +6,13 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/pytypes.h>
 
-#include <functional>
 #include <memory>
 #include <string>
-#include <type_traits>
-#include <utility>
 
-#include "google/protobuf/descriptor.h"
-#include "google/protobuf/message.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
 
 // PYBIND11_PROTOBUF_ASSUME_FULL_ABI_COMPATIBILITY can be defined by users
 // certain about ABI compatibility between all Python extensions in their
@@ -52,11 +49,13 @@ absl::string_view PyBytesAsStringView(pybind11::bytes py_bytes);
 // various protobuf-related modules.
 void InitializePybindProtoCastUtil();
 
-// Imports a module pertaining to a given ::google::protobuf::Descriptor, if possible.
-void ImportProtoDescriptorModule(const ::google::protobuf::Descriptor *);
+// Imports a module pertaining to a given google::protobuf::Descriptor, if
+// possible.
+void ImportProtoDescriptorModule(const google::protobuf::Descriptor *);
 
-// Returns a ::google::protobuf::Message* from a cpp_fast_proto, if backed by C++.
-const ::google::protobuf::Message *PyProtoGetCppMessagePointer(pybind11::handle src);
+// Returns a google::protobuf::Message* from a cpp_fast_proto, if backed by
+// C++.
+const google::protobuf::Message *PyProtoGetCppMessagePointer(pybind11::handle src);
 
 // Returns the protocol buffer's py_proto.DESCRIPTOR.full_name attribute.
 absl::optional<std::string> PyProtoDescriptorFullName(
@@ -64,31 +63,31 @@ absl::optional<std::string> PyProtoDescriptorFullName(
 
 // Returns true if py_proto full name matches descriptor full name.
 bool PyProtoHasMatchingFullName(pybind11::handle py_proto,
-                                const ::google::protobuf::Descriptor *descriptor);
+                                const google::protobuf::Descriptor *descriptor);
 
 // Caller should enforce any type identity that is required.
 pybind11::bytes PyProtoSerializePartialToString(pybind11::handle py_proto,
                                                 bool raise_if_error);
 
 // Allocates a C++ protocol buffer for a given name.
-std::unique_ptr<::google::protobuf::Message> AllocateCProtoFromPythonSymbolDatabase(
+std::unique_ptr<google::protobuf::Message> AllocateCProtoFromPythonSymbolDatabase(
     pybind11::handle src, const std::string &full_name);
 
 // Serialize the py_proto and deserialize it into the provided message.
 // Caller should enforce any type identity that is required.
-void CProtoCopyToPyProto(::google::protobuf::Message *message, pybind11::handle py_proto);
+void CProtoCopyToPyProto(google::protobuf::Message *message, pybind11::handle py_proto);
 
 // Returns a handle to a python protobuf suitably
-pybind11::handle GenericFastCppProtoCast(::google::protobuf::Message *src,
+pybind11::handle GenericFastCppProtoCast(google::protobuf::Message *src,
                                          pybind11::return_value_policy policy,
                                          pybind11::handle parent,
                                          bool is_const);
 
-pybind11::handle GenericPyProtoCast(::google::protobuf::Message *src,
+pybind11::handle GenericPyProtoCast(google::protobuf::Message *src,
                                     pybind11::return_value_policy policy,
                                     pybind11::handle parent, bool is_const);
 
-pybind11::handle GenericProtoCast(::google::protobuf::Message *src,
+pybind11::handle GenericProtoCast(google::protobuf::Message *src,
                                   pybind11::return_value_policy policy,
                                   pybind11::handle parent, bool is_const);
 
diff --git a/pybind11_protobuf/proto_caster_impl.h b/pybind11_protobuf/proto_caster_impl.h
index 12e693d..3105460 100644
--- a/pybind11_protobuf/proto_caster_impl.h
+++ b/pybind11_protobuf/proto_caster_impl.h
@@ -8,15 +8,13 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/pytypes.h>
 
-#include <functional>
 #include <memory>
 #include <optional>
-#include <string>
 #include <type_traits>
 #include <utility>
 
-#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/descriptor.h"
+#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/message.h"
 #include "pybind11_protobuf/proto_cast_util.h"
 
@@ -52,10 +50,10 @@ struct proto_caster_load_impl {
 
     // Attempt to use the PyProto_API to get an underlying C++ message pointer
     // from the object.
-    const ::google::protobuf::Message *message =
+    const google::protobuf::Message *message =
         pybind11_protobuf::PyProtoGetCppMessagePointer(src);
     if (message) {
-      value = ::google::protobuf::DynamicCastToGenerated<ProtoType>(message);
+      value = google::protobuf::DynamicCastToGenerated<ProtoType>(message);
       if (value) {
         // If the capability were available, then we could probe PyProto_API and
         // allow c++ mutability based on the python reference count.
@@ -74,12 +72,11 @@ struct proto_caster_load_impl {
 
     owned = std::unique_ptr<ProtoType>(new ProtoType());
     value = owned.get();
-    return owned.get()->ParsePartialFromString(
-        PyBytesAsStringView(serialized_bytes));
+    return owned->ParsePartialFromString(PyBytesAsStringView(serialized_bytes));
   }
 
   // ensure_owned ensures that the owned member contains a copy of the
-  // ::google::protobuf::Message.
+  // google::protobuf::Message.
   void ensure_owned() {
     if (value && !owned) {
       owned = std::unique_ptr<ProtoType>(value->New());
@@ -93,8 +90,8 @@ struct proto_caster_load_impl {
 };
 
 template <>
-struct proto_caster_load_impl<::google::protobuf::Message> {
-  using ProtoType = ::google::protobuf::Message;
+struct proto_caster_load_impl<google::protobuf::Message> {
+  using ProtoType = google::protobuf::Message;
 
   bool load(pybind11::handle src, bool convert) {
     if (src.is_none()) {
@@ -126,12 +123,11 @@ struct proto_caster_load_impl<::google::protobuf::Message> {
             src, *descriptor_name)
             .release()));
     value = owned.get();
-    return owned.get()->ParsePartialFromString(
-        PyBytesAsStringView(serialized_bytes));
+    return owned->ParsePartialFromString(PyBytesAsStringView(serialized_bytes));
   }
 
   // ensure_owned ensures that the owned member contains a copy of the
-  // ::google::protobuf::Message.
+  // google::protobuf::Message.
   void ensure_owned() {
     if (value && !owned) {
       owned = std::unique_ptr<ProtoType>(value->New());
@@ -140,12 +136,12 @@ struct proto_caster_load_impl<::google::protobuf::Message> {
     }
   }
 
-  const ::google::protobuf::Message *value;
-  std::unique_ptr<::google::protobuf::Message> owned;
+  const google::protobuf::Message *value;
+  std::unique_ptr<google::protobuf::Message> owned;
 };
 
 struct fast_cpp_cast_impl {
-  inline static pybind11::handle cast_impl(::google::protobuf::Message *src,
+  inline static pybind11::handle cast_impl(google::protobuf::Message *src,
                                            pybind11::return_value_policy policy,
                                            pybind11::handle parent,
                                            bool is_const) {
@@ -156,7 +152,8 @@ struct fast_cpp_cast_impl {
         (policy == pybind11::return_value_policy::reference ||
          policy == pybind11::return_value_policy::reference_internal)) {
       throw pybind11::type_error(
-          "Cannot return a const reference to a ::google::protobuf::Message derived "
+          "Cannot return a const reference to a google::protobuf::Message "
+          "derived "
           "type.  Consider setting return_value_policy::copy in the "
           "pybind11 def().");
     }
@@ -174,7 +171,7 @@ struct fast_cpp_cast_impl {
 };
 
 struct native_cast_impl {
-  inline static pybind11::handle cast_impl(::google::protobuf::Message *src,
+  inline static pybind11::handle cast_impl(google::protobuf::Message *src,
                                            pybind11::return_value_policy policy,
                                            pybind11::handle parent,
                                            bool is_const) {
diff --git a/pybind11_protobuf/proto_utils.cc b/pybind11_protobuf/proto_utils.cc
index 2701727..a8348bb 100644
--- a/pybind11_protobuf/proto_utils.cc
+++ b/pybind11_protobuf/proto_utils.cc
@@ -7,17 +7,20 @@
 
 #include <pybind11/functional.h>
 
-#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <functional>
 #include <memory>
 #include <stdexcept>
 #include <string>
+#include <utility>
 
-#include "google/protobuf/descriptor.pb.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 #include "google/protobuf/descriptor.h"
+#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/message.h"
 #include "google/protobuf/reflection.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 
 namespace pybind11 {
 namespace google {
@@ -30,16 +33,16 @@ namespace google {
 // It code be moved back to proto_utils.h with added unit testing.
 
 // Gets the field with the given name from the given message as a python object.
-object ProtoGetField(::google::protobuf::Message* message, absl::string_view name);
-object ProtoGetField(::google::protobuf::Message* message,
-                     const ::google::protobuf::FieldDescriptor* field_desc);
+object ProtoGetField(google::protobuf::Message* message, absl::string_view name);
+object ProtoGetField(google::protobuf::Message* message,
+                     const google::protobuf::FieldDescriptor* field_desc);
 
 // Sets the field with the given name in the given message from a python object.
 // As in the native API, message, repeated, and map fields cannot be set.
-void ProtoSetField(::google::protobuf::Message* message, absl::string_view name,
+void ProtoSetField(google::protobuf::Message* message, absl::string_view name,
                    handle value);
-void ProtoSetField(::google::protobuf::Message* message,
-                   const ::google::protobuf::FieldDescriptor* field_desc, handle value);
+void ProtoSetField(google::protobuf::Message* message,
+                   const google::protobuf::FieldDescriptor* field_desc, handle value);
 
 // If py_proto is a native c or wrapped python proto, sets name and returns
 // true. If py_proto is not a proto, returns false.
@@ -59,7 +62,7 @@ bool PyProtoCheckType(handle py_proto) {
 // Returns whether py_proto is a proto based on whether it has a descriptor
 // with the name of the proto.
 template <>
-inline bool PyProtoCheckType<::google::protobuf::Message>(handle py_proto) {
+inline bool PyProtoCheckType<google::protobuf::Message>(handle py_proto) {
   return PyProtoFullName(py_proto, nullptr);
 }
 
@@ -68,11 +71,11 @@ std::string PyProtoSerializeToString(handle py_proto);
 
 // Gets the descriptor for the proto specified by the argument, which can be a
 // native python proto, a wrapped C proto, or a string with the full type name.
-const ::google::protobuf::Descriptor* PyProtoGetDescriptor(handle py_proto);
+const google::protobuf::Descriptor* PyProtoGetDescriptor(handle py_proto);
 
 // Allocate and return a message instance for the given descriptor.
-std::unique_ptr<::google::protobuf::Message> PyProtoAllocateMessage(
-    const ::google::protobuf::Descriptor* descriptor, kwargs kwargs_in);
+std::unique_ptr<google::protobuf::Message> PyProtoAllocateMessage(
+    const google::protobuf::Descriptor* descriptor, kwargs kwargs_in);
 
 // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 // END CODE MOVED HERE FROM proto_utils.h
@@ -94,35 +97,35 @@ struct GenericEnum {};
 // template functions don't exist in C++, so you must define a class with a
 // static member function (HandleField) which will be called.
 template <template <typename> class Handler, typename... Args>
-auto DispatchFieldDescriptor(const ::google::protobuf::FieldDescriptor* field_desc,
+auto DispatchFieldDescriptor(const google::protobuf::FieldDescriptor* field_desc,
                              Args... args)
     -> decltype(Handler<int32_t>::HandleField(field_desc, args...)) {
   // If this field is a map, the field_desc always describes a message with
   // 2 fields: key and value. In that case, dispatch based on the value type.
   // In all other cases, the value type is the same as the field type.
-  const ::google::protobuf::FieldDescriptor* field_value_desc = field_desc;
+  const google::protobuf::FieldDescriptor* field_value_desc = field_desc;
   if (field_desc->is_map())
     field_value_desc = field_desc->message_type()->FindFieldByName("value");
   switch (field_value_desc->cpp_type()) {
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_INT32:
+    case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
       return Handler<int32_t>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_INT64:
+    case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
       return Handler<int64_t>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
+    case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
       return Handler<uint32_t>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
+    case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
       return Handler<uint64_t>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
+    case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
       return Handler<float>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
+    case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
       return Handler<double>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
+    case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
       return Handler<bool>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_STRING:
+    case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
       return Handler<std::string>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:
-      return Handler<::google::protobuf::Message>::HandleField(field_desc, args...);
-    case ::google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
+    case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:
+      return Handler<google::protobuf::Message>::HandleField(field_desc, args...);
+    case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
       return Handler<GenericEnum>::HandleField(field_desc, args...);
     default:
       throw std::runtime_error("Unknown cpp_type: " +
@@ -149,9 +152,9 @@ class ProtoFieldContainerBase {
   // In that case, it should point to the message which contains the map field.
   // (ie, the parent of the key-value pair). In all other cases, `proto` is
   // also the parent, which is indicated by passing nullptr for `parent`.
-  ProtoFieldContainerBase(::google::protobuf::Message* proto,
-                          const ::google::protobuf::FieldDescriptor* field_desc,
-                          ::google::protobuf::Message* parent = nullptr)
+  ProtoFieldContainerBase(google::protobuf::Message* proto,
+                          const google::protobuf::FieldDescriptor* field_desc,
+                          google::protobuf::Message* parent = nullptr)
       : proto_(proto),
         parent_(parent ? parent : proto),
         field_desc_(field_desc),
@@ -206,10 +209,10 @@ class ProtoFieldContainerBase {
     return py_inst;
   }
 
-  ::google::protobuf::Message* proto_;
-  ::google::protobuf::Message* parent_;
-  const ::google::protobuf::FieldDescriptor* field_desc_;
-  const ::google::protobuf::Reflection* reflection_;
+  google::protobuf::Message* proto_;
+  google::protobuf::Message* parent_;
+  const google::protobuf::FieldDescriptor* field_desc_;
+  const google::protobuf::Reflection* reflection_;
 };
 
 // Create a template-specialization based reflection interface,
@@ -302,7 +305,7 @@ class ProtoFieldContainer<std::string> : public ProtoFieldContainerBase {
     // to decode them as utf-8. However, some byte sequences are illegal in
     // utf-8, and will result in an error. To allow any arbitrary byte sequence
     // for a bytes field, we have to convert it to a python bytes type.
-    if (field_desc_->type() == ::google::protobuf::FieldDescriptor::TYPE_BYTES)
+    if (field_desc_->type() == google::protobuf::FieldDescriptor::TYPE_BYTES)
       return bytes(Get(idx));
     else
       return str(Get(idx));
@@ -323,7 +326,7 @@ class ProtoFieldContainer<std::string> : public ProtoFieldContainerBase {
                            CastOrTypeError<std::string>(value));
   }
   std::string ElementRepr(int idx) const {
-    if (field_desc_->type() == ::google::protobuf::FieldDescriptor::TYPE_BYTES)
+    if (field_desc_->type() == google::protobuf::FieldDescriptor::TYPE_BYTES)
       return "<Binary String>";
     else
       return "'" + Get(idx) + "'";
@@ -335,11 +338,11 @@ class ProtoFieldContainer<std::string> : public ProtoFieldContainerBase {
 
 // Specialization for messages.
 template <>
-class ProtoFieldContainer<::google::protobuf::Message> : public ProtoFieldContainerBase {
+class ProtoFieldContainer<google::protobuf::Message> : public ProtoFieldContainerBase {
  public:
   using ProtoFieldContainerBase::ProtoFieldContainerBase;
-  ::google::protobuf::Message* Get(int idx) const {
-    ::google::protobuf::Message* message;
+  google::protobuf::Message* Get(int idx) const {
+    google::protobuf::Message* message;
     if (field_desc_->is_repeated()) {
       message = reflection_->MutableRepeatedMessage(proto_, field_desc_,
                                                     CheckIndex(idx));
@@ -351,7 +354,7 @@ class ProtoFieldContainer<::google::protobuf::Message> : public ProtoFieldContai
   object GetPython(int idx) const {
     return this->CastAndKeepAlive(Get(idx), return_value_policy::reference);
   }
-  void Set(int idx, ::google::protobuf::Message* value) {
+  void Set(int idx, google::protobuf::Message* value) {
     if (value->GetTypeName() != field_desc_->message_type()->full_name())
       throw type_error("Cannot set field from invalid type.");
     Get(idx)->CopyFrom(*value);
@@ -365,14 +368,14 @@ class ProtoFieldContainer<::google::protobuf::Message> : public ProtoFieldContai
     CheckValueType(value);
     reflection_->AddAllocatedMessage(
         proto_, field_desc_,
-        PyProtoAllocateAndCopyMessage<::google::protobuf::Message>(value).release());
+        PyProtoAllocateAndCopyMessage<google::protobuf::Message>(value).release());
   }
-  ::google::protobuf::Message* Add(kwargs kwargs_in = kwargs()) {
+  google::protobuf::Message* Add(kwargs kwargs_in = kwargs()) {
     // Use a unique_ptr because it will automatically free memory if
     // ProtoInitFields throws an exception.
-    std::unique_ptr<::google::protobuf::Message> new_msg = std::unique_ptr<::google::protobuf::Message>(
+    std::unique_ptr<google::protobuf::Message> new_msg = std::unique_ptr<google::protobuf::Message>(
         reflection_
-            ->GetMutableRepeatedFieldRef<::google::protobuf::Message>(proto_, field_desc_)
+            ->GetMutableRepeatedFieldRef<google::protobuf::Message>(proto_, field_desc_)
             .NewMessage());
     ProtoInitFields(new_msg.get(), kwargs_in);
     // Transfer ownership of the new message to the proto repeated field.
@@ -396,7 +399,7 @@ template <>
 class ProtoFieldContainer<GenericEnum> : public ProtoFieldContainerBase {
  public:
   using ProtoFieldContainerBase::ProtoFieldContainerBase;
-  const ::google::protobuf::EnumValueDescriptor* GetDesc(int idx) const {
+  const google::protobuf::EnumValueDescriptor* GetDesc(int idx) const {
     if (field_desc_->is_repeated()) {
       return reflection_->GetRepeatedEnum(*proto_, field_desc_,
                                           CheckIndex(idx));
@@ -510,26 +513,26 @@ class RepeatedFieldContainer : public ProtoFieldContainer<T> {
 // the map pair (key, value) message with the given key.
 template <typename KeyT>
 struct FindMapPair {
-  static ::google::protobuf::Message* HandleField(const ::google::protobuf::FieldDescriptor* key_desc,
-                                      ::google::protobuf::Message* proto,
-                                      const ::google::protobuf::FieldDescriptor* map_desc,
+  static google::protobuf::Message* HandleField(const google::protobuf::FieldDescriptor* key_desc,
+                                      google::protobuf::Message* proto,
+                                      const google::protobuf::FieldDescriptor* map_desc,
                                       handle key, bool add_key = true) {
     // When using the proto reflection API, maps are represented as repeated
     // message fields (messages with 2 elements: 'key' and 'value'). If protocol
-    // buffers guarrantee a consistent (and useful) ordering of elements,
+    // buffers guarantee a consistent (and useful) ordering of elements,
     // it should be possible to do this search in O(log(n)) time. However, that
     // requires more knowledge of protobuf internals than I have, so for now
     // assume a random ordering of elements, in which case a O(n) search is
     // the best you can do.
-    RepeatedFieldContainer<::google::protobuf::Message> map_field(proto, map_desc);
+    RepeatedFieldContainer<google::protobuf::Message> map_field(proto, map_desc);
     for (int i = 0; i < map_field.Size(); ++i) {
-      ::google::protobuf::Message* kv_pair = map_field.Get(i);
+      google::protobuf::Message* kv_pair = map_field.Get(i);
       if (ProtoFieldContainer<KeyT>(kv_pair, key_desc).GetPython(-1).equal(key))
         return kv_pair;
     }
     // Key not found
     if (!add_key) return nullptr;
-    ::google::protobuf::Message* new_kv_pair = map_field.Add();
+    google::protobuf::Message* new_kv_pair = map_field.Add();
     ProtoFieldContainer<KeyT>(new_kv_pair, key_desc).SetPython(-1, key);
     return new_kv_pair;
   }
@@ -539,8 +542,8 @@ struct FindMapPair {
 // the map key.
 template <typename KeyType>
 struct GetMapKey {
-  static object HandleField(const ::google::protobuf::FieldDescriptor* key_desc,
-                            ::google::protobuf::Message* kv_pair, ::google::protobuf::Message* parent) {
+  static object HandleField(const google::protobuf::FieldDescriptor* key_desc,
+                            google::protobuf::Message* kv_pair, google::protobuf::Message* parent) {
     return ProtoFieldContainer<KeyType>(kv_pair, key_desc, parent)
         .GetPython(-1);
   }
@@ -550,22 +553,22 @@ struct GetMapKey {
 // representation of the map key.
 template <typename KeyType>
 struct GetMapKeyRepr {
-  static std::string HandleField(const ::google::protobuf::FieldDescriptor* key_desc,
-                                 ::google::protobuf::Message* kv_pair) {
+  static std::string HandleField(const google::protobuf::FieldDescriptor* key_desc,
+                                 google::protobuf::Message* kv_pair) {
     return ProtoFieldContainer<KeyType>(kv_pair, key_desc).ElementRepr(-1);
   }
 };
 
 // Container for a map field.
 template <typename MappedType>
-class MapFieldContainer : public RepeatedFieldContainer<::google::protobuf::Message> {
+class MapFieldContainer : public RepeatedFieldContainer<google::protobuf::Message> {
  public:
-  MapFieldContainer(::google::protobuf::Message* proto,
-                    const ::google::protobuf::FieldDescriptor* map_desc)
-      : RepeatedFieldContainer<::google::protobuf::Message>(proto, map_desc),
+  MapFieldContainer(google::protobuf::Message* proto,
+                    const google::protobuf::FieldDescriptor* map_desc)
+      : RepeatedFieldContainer<google::protobuf::Message>(proto, map_desc),
         key_desc_(map_desc->message_type()->FindFieldByName("key")),
         value_desc_(map_desc->message_type()->FindFieldByName("value")) {}
-  using RepeatedFieldContainer<::google::protobuf::Message>::RepeatedFieldContainer;
+  using RepeatedFieldContainer<google::protobuf::Message>::RepeatedFieldContainer;
   object GetPythonContainer() const {
     return this->CastAndKeepAlive(this, return_value_policy::copy);
   }
@@ -594,7 +597,7 @@ class MapFieldContainer : public RepeatedFieldContainer<::google::protobuf::Mess
     if (Size() == 0) return "{}";
     std::string repr = "{";
     for (int i = 0; i < Size(); ++i) {
-      ::google::protobuf::Message* kv_pair = Get(i);
+      google::protobuf::Message* kv_pair = Get(i);
       repr += DispatchFieldDescriptor<GetMapKeyRepr>(key_desc_, kv_pair) +
               ": " +
               ProtoFieldContainer<MappedType>(kv_pair, value_desc_)
@@ -605,7 +608,7 @@ class MapFieldContainer : public RepeatedFieldContainer<::google::protobuf::Mess
     repr.back() = '}';
     return repr;
   }
-  std::function<std::unique_ptr<::google::protobuf::Message>(kwargs)>
+  std::function<std::unique_ptr<google::protobuf::Message>(kwargs)>
   GetEntryClassFactory() {
     return [descriptor = field_desc_->message_type()](kwargs kwargs_in) {
       return PyProtoAllocateMessage(descriptor, kwargs_in);
@@ -619,7 +622,7 @@ class MapFieldContainer : public RepeatedFieldContainer<::google::protobuf::Mess
     // the appropriate value from a key-value pair message (ie, this function
     // should return either the key, the value, or a (key, value) tuple).
     Iterator(MapFieldContainer* container,
-             object (MapFieldContainer::*value_helper)(::google::protobuf::Message*))
+             object (MapFieldContainer::*value_helper)(google::protobuf::Message*))
         : container_(container), value_helper_(value_helper) {}
 
     auto* iter() { return this; }
@@ -630,7 +633,7 @@ class MapFieldContainer : public RepeatedFieldContainer<::google::protobuf::Mess
 
    private:
     MapFieldContainer* container_;
-    object (MapFieldContainer::*value_helper_)(::google::protobuf::Message*);
+    object (MapFieldContainer::*value_helper_)(google::protobuf::Message*);
     int idx_ = 0;
   };
 
@@ -648,33 +651,33 @@ class MapFieldContainer : public RepeatedFieldContainer<::google::protobuf::Mess
 
   // Get the ProtoFieldContainer for the value corresponding to the given key.
   ProtoFieldContainer<MappedType> GetValueContainer(handle key) const {
-    ::google::protobuf::Message* kv_pair = DispatchFieldDescriptor<FindMapPair>(
+    google::protobuf::Message* kv_pair = DispatchFieldDescriptor<FindMapPair>(
         key_desc_, proto_, field_desc_, key);
     return ProtoFieldContainer<MappedType>(kv_pair, value_desc_, proto_);
   }
 
   // Get the key out of the given key-value message.
-  object GetKey(::google::protobuf::Message* kv_pair) {
+  object GetKey(google::protobuf::Message* kv_pair) {
     return DispatchFieldDescriptor<GetMapKey>(key_desc_, kv_pair, proto_);
   }
 
   // Get the value out of the given key-value message.
-  object GetValue(::google::protobuf::Message* kv_pair) {
+  object GetValue(google::protobuf::Message* kv_pair) {
     return ProtoFieldContainer<MappedType>(kv_pair, value_desc_, proto_)
         .GetPython(-1);
   }
 
   // Get the given key-value pair as a message.
-  object GetTuple(::google::protobuf::Message* kv_pair) {
+  object GetTuple(google::protobuf::Message* kv_pair) {
     return make_tuple(GetKey(kv_pair), GetValue(kv_pair));
   }
 
-  const ::google::protobuf::FieldDescriptor* key_desc_;
-  const ::google::protobuf::FieldDescriptor* value_desc_;
+  const google::protobuf::FieldDescriptor* key_desc_;
+  const google::protobuf::FieldDescriptor* value_desc_;
 };
 
-const ::google::protobuf::FieldDescriptor* GetFieldDescriptor(
-    ::google::protobuf::Message* message, absl::string_view name,
+const google::protobuf::FieldDescriptor* GetFieldDescriptor(
+    google::protobuf::Message* message, absl::string_view name,
     PyObject* error_type = PyExc_AttributeError) {
   auto* field_desc =
   message->GetDescriptor()->FindFieldByName(std::string(name));
@@ -691,8 +694,8 @@ const ::google::protobuf::FieldDescriptor* GetFieldDescriptor(
 // Struct used with DispatchFieldDescriptor to get the value of a field.
 template <typename ValueType>
 struct TemplatedProtoGetField {
-  static object HandleField(const ::google::protobuf::FieldDescriptor* field_desc,
-                            ::google::protobuf::Message* proto) {
+  static object HandleField(const google::protobuf::FieldDescriptor* field_desc,
+                            google::protobuf::Message* proto) {
     if (field_desc->is_map()) {
       return MapFieldContainer<ValueType>(proto, field_desc)
           .GetPythonContainer();
@@ -708,8 +711,8 @@ struct TemplatedProtoGetField {
 // Struct used with DispatchFieldDescriptor to set the value of a field.
 template <typename ValueType>
 struct TemplatedProtoSetField {
-  static void HandleField(const ::google::protobuf::FieldDescriptor* field_desc,
-                          ::google::protobuf::Message* proto, handle value) {
+  static void HandleField(const google::protobuf::FieldDescriptor* field_desc,
+                          google::protobuf::Message* proto, handle value) {
     if (field_desc->is_map()) {
       MapFieldContainer<ValueType> map_field(proto, field_desc);
       map_field.Clear();
@@ -762,11 +765,11 @@ std::string PyProtoSerializeToString(handle py_proto) {
   throw std::invalid_argument("Passed python object is not a proto.");
 }
 
-const ::google::protobuf::Descriptor* PyProtoGetDescriptor(handle py_proto) {
-  detail::make_caster<::google::protobuf::Message> caster;
+const google::protobuf::Descriptor* PyProtoGetDescriptor(handle py_proto) {
+  detail::make_caster<google::protobuf::Message> caster;
   if (caster.load(py_proto, true)) {
     // Native C++ proto, so we can get the descriptor directly.
-    return detail::cast_op<::google::protobuf::Message*>(caster)->GetDescriptor();
+    return detail::cast_op<google::protobuf::Message*>(caster)->GetDescriptor();
   }
 
   // Look the descriptor based on the proto's type name.
@@ -778,8 +781,8 @@ const ::google::protobuf::Descriptor* PyProtoGetDescriptor(handle py_proto) {
   } else if (!PyProtoFullName(py_proto, &full_type_name)) {
     throw std::invalid_argument("Could not get the name of the proto.");
   }
-  const ::google::protobuf::Descriptor* descriptor =
-      ::google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName(
+  const google::protobuf::Descriptor* descriptor =
+      google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName(
           full_type_name);
   if (!descriptor)
     throw std::runtime_error("Proto Descriptor not found: " + full_type_name);
@@ -787,43 +790,43 @@ const ::google::protobuf::Descriptor* PyProtoGetDescriptor(handle py_proto) {
 }
 
 template <>
-std::unique_ptr<::google::protobuf::Message> PyProtoAllocateMessage(handle py_proto,
+std::unique_ptr<google::protobuf::Message> PyProtoAllocateMessage(handle py_proto,
                                                         kwargs kwargs_in) {
   return PyProtoAllocateMessage(PyProtoGetDescriptor(py_proto), kwargs_in);
 }
 
-std::unique_ptr<::google::protobuf::Message> PyProtoAllocateMessage(
-    const ::google::protobuf::Descriptor* descriptor, kwargs kwargs_in) {
-  const ::google::protobuf::Message* prototype =
-      ::google::protobuf::MessageFactory::generated_factory()->GetPrototype(descriptor);
+std::unique_ptr<google::protobuf::Message> PyProtoAllocateMessage(
+    const google::protobuf::Descriptor* descriptor, kwargs kwargs_in) {
+  const google::protobuf::Message* prototype =
+      google::protobuf::MessageFactory::generated_factory()->GetPrototype(descriptor);
   if (!prototype) {
     throw std::runtime_error(
         absl::StrCat("Not able to generate prototype for descriptor of: ",
                      descriptor->full_name()));
   }
-  auto message = std::unique_ptr<::google::protobuf::Message>(prototype->New());
+  auto message = std::unique_ptr<google::protobuf::Message>(prototype->New());
   ProtoInitFields(message.get(), kwargs_in);
   return message;
 }
 
-object ProtoGetField(::google::protobuf::Message* message, absl::string_view name) {
+object ProtoGetField(google::protobuf::Message* message, absl::string_view name) {
   return ProtoGetField(message, GetFieldDescriptor(message, name));
 }
 
-object ProtoGetField(::google::protobuf::Message* message,
-                     const ::google::protobuf::FieldDescriptor* field_desc) {
+object ProtoGetField(google::protobuf::Message* message,
+                     const google::protobuf::FieldDescriptor* field_desc) {
   return DispatchFieldDescriptor<TemplatedProtoGetField>(field_desc, message);
 }
 
-void ProtoSetField(::google::protobuf::Message* message, absl::string_view name,
+void ProtoSetField(google::protobuf::Message* message, absl::string_view name,
                    handle value) {
   ProtoSetField(message, GetFieldDescriptor(message, name), value);
 }
 
-void ProtoSetField(::google::protobuf::Message* message,
-                   const ::google::protobuf::FieldDescriptor* field_desc, handle value) {
+void ProtoSetField(google::protobuf::Message* message,
+                   const google::protobuf::FieldDescriptor* field_desc, handle value) {
   if (field_desc->is_map() || field_desc->is_repeated() ||
-      field_desc->type() == ::google::protobuf::FieldDescriptor::TYPE_MESSAGE) {
+      field_desc->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) {
     std::string error =
         absl::StrCat("Assignment not allowed to field \"", field_desc->name(),
                      "\" in protocol message object.");
@@ -833,7 +836,7 @@ void ProtoSetField(::google::protobuf::Message* message,
   DispatchFieldDescriptor<TemplatedProtoSetField>(field_desc, message, value);
 }
 
-void ProtoInitFields(::google::protobuf::Message* message, kwargs kwargs_in) {
+void ProtoInitFields(google::protobuf::Message* message, kwargs kwargs_in) {
   // NOTE: This uses pybind11 casters to construct strings, so it needs to
   // be wrapped by loader_life_support.
   pybind11::detail::loader_life_support life_support;
@@ -845,11 +848,11 @@ void ProtoInitFields(::google::protobuf::Message* message, kwargs kwargs_in) {
   }
 }
 
-void ProtoCopyFrom(::google::protobuf::Message* msg, handle other) {
+void ProtoCopyFrom(google::protobuf::Message* msg, handle other) {
   PyProtoCheckTypeOrThrow(other, msg->GetTypeName());
-  detail::type_caster_base<::google::protobuf::Message> caster;
+  detail::type_caster_base<google::protobuf::Message> caster;
   if (caster.load(other, false)) {
-    msg->CopyFrom(static_cast<::google::protobuf::Message&>(caster));
+    msg->CopyFrom(static_cast<google::protobuf::Message&>(caster));
   } else {
     if (!msg->ParseFromString(PyProtoSerializeToString(other)))
       throw std::runtime_error("Error copying message.");
diff --git a/pybind11_protobuf/proto_utils.h b/pybind11_protobuf/proto_utils.h
index 1b2c084..86e37a1 100644
--- a/pybind11_protobuf/proto_utils.h
+++ b/pybind11_protobuf/proto_utils.h
@@ -17,12 +17,12 @@ namespace google {
 
 // Initializes the fields in the given message from the the keyword args.
 // Unlike ProtoSetField, this allows setting message, map and repeated fields.
-void ProtoInitFields(::google::protobuf::Message* message, kwargs kwargs_in);
+void ProtoInitFields(google::protobuf::Message* message, kwargs kwargs_in);
 
-// Wrapper around ::google::protobuf::Message::CopyFrom which can efficiently copy from
-// either a wrapped C++ or native python proto. Throws an error if `other`
-// is not a proto of the correct type.
-void ProtoCopyFrom(::google::protobuf::Message* msg, handle other);
+// Wrapper around google::protobuf::Message::CopyFrom which can efficiently
+// copy from either a wrapped C++ or native python proto. Throws an error if
+// `other` is not a proto of the correct type.
+void ProtoCopyFrom(google::protobuf::Message* msg, handle other);
 
 // Allocate and return the ProtoType given by the template argument.
 // py_proto is not used in this version, but is used by a specialization below.
@@ -38,7 +38,7 @@ std::unique_ptr<ProtoType> PyProtoAllocateMessage(handle py_proto = handle(),
 // The type is pulled from the py_proto, which can be a native python proto,
 // a wrapped C proto, or a string with the full type name.
 template <>
-std::unique_ptr<::google::protobuf::Message> PyProtoAllocateMessage(handle py_proto,
+std::unique_ptr<google::protobuf::Message> PyProtoAllocateMessage(handle py_proto,
                                                         kwargs kwargs_in);
 
 // Allocate a C++ proto of the same type as py_proto and copy the contents
diff --git a/pybind11_protobuf/tests/BUILD b/pybind11_protobuf/tests/BUILD
index 2cca967..8b2fb6e 100644
--- a/pybind11_protobuf/tests/BUILD
+++ b/pybind11_protobuf/tests/BUILD
@@ -16,7 +16,7 @@ py_library(
     srcs = ["compare.py"],
     srcs_version = "PY3",
     visibility = ["//visibility:public"],
-    deps = ["@com_google_protobuf//:protobuf_python"],
+    deps = ["//third_party/py/google/protobuf"],
 )
 
 proto_library(
@@ -141,6 +141,7 @@ pybind_extension(
     srcs = ["dynamic_message_module.cc"],
     deps = [
         "//pybind11_protobuf:native_proto_caster",
+        "//third_party/protobuf:descriptor_pb",
         "@com_google_protobuf//:protobuf",
     ],
 )
@@ -154,9 +155,10 @@ py_test(
     deps = [
         ":compare",
         ":test_py_pb2",
-        "@com_google_protobuf//:protobuf_python",
         "@com_google_absl_py//absl/testing:absltest",
         "@com_google_absl_py//absl/testing:parameterized",
+        "@com_google_protobuf//:protobuf_python",
+        "//third_party/py/google/protobuf",
         requirement("absl_py"),
     ],
 )
@@ -223,6 +225,7 @@ py_test(
         "@com_google_protobuf//:protobuf_python",
         "@com_google_absl_py//absl/testing:absltest",
         "@com_google_absl_py//absl/testing:parameterized",
+        "//third_party/py/google/protobuf",
         requirement("absl_py"),
     ],
 )
@@ -233,6 +236,7 @@ pybind_extension(
     deps = [
         ":test_cc_proto",
         "//pybind11_protobuf:native_proto_caster",
+        "//third_party/protobuf:descriptor_pb",
         "@com_google_protobuf//:protobuf",
     ],
 )
@@ -245,9 +249,10 @@ py_test(
     srcs_version = "PY3",
     deps = [
         ":test_py_pb2",
-        "@com_google_protobuf//:protobuf_python",
         "@com_google_absl_py//absl/testing:absltest",
         "@com_google_absl_py//absl/testing:parameterized",
+        "@com_google_protobuf//:protobuf_python",
+        "//third_party/py/google/protobuf",
         requirement("absl_py"),
     ],
 )
@@ -270,6 +275,7 @@ pybind_extension(
     deps = [
         ":test_cc_proto",
         "//pybind11_protobuf:wrapped_proto_caster",
+        "@com_google_absl//absl/functional:function_ref",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/types:optional",
         "@com_google_protobuf//:protobuf",
diff --git a/pybind11_protobuf/tests/dynamic_message_module.cc b/pybind11_protobuf/tests/dynamic_message_module.cc
index 21edd96..46c2b6f 100644
--- a/pybind11_protobuf/tests/dynamic_message_module.cc
+++ b/pybind11_protobuf/tests/dynamic_message_module.cc
@@ -5,12 +5,14 @@
 
 #include <pybind11/pybind11.h>
 
-#include <functional>
+#include <cassert>
+#include <cstdint>
 #include <memory>
 #include <stdexcept>
+#include <string>
 
-#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/descriptor.h"
+#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/dynamic_message.h"
 #include "google/protobuf/message.h"
 #include "google/protobuf/text_format.h"
@@ -24,10 +26,10 @@ namespace {
 // with IntMessage; conversion using the fast_cpp_proto api will fail
 // as the PyProto_API will not be able to find the proto in the default
 // pool.
-::google::protobuf::DescriptorPool* GetDynamicPool() {
-  static ::google::protobuf::DescriptorPool* pool = [] {
-    ::google::protobuf::FileDescriptorProto file_proto;
-    if (!::google::protobuf::TextFormat::ParseFromString(
+google::protobuf::DescriptorPool* GetDynamicPool() {
+  static google::protobuf::DescriptorPool* pool = [] {
+    google::protobuf::FileDescriptorProto file_proto;
+    if (!google::protobuf::TextFormat::ParseFromString(
             R"pb(
               name: 'pybind11_protobuf/tests'
               package: 'pybind11.test'
@@ -44,7 +46,7 @@ ::google::protobuf::DescriptorPool* GetDynamicPool() {
       throw std::invalid_argument("Failed to parse textproto.");
     }
 
-    ::google::protobuf::DescriptorPool* pool = new ::google::protobuf::DescriptorPool();
+    google::protobuf::DescriptorPool* pool = new google::protobuf::DescriptorPool();
     pool->BuildFile(file_proto);
     return pool;
   }();
@@ -52,23 +54,23 @@ ::google::protobuf::DescriptorPool* GetDynamicPool() {
   return pool;
 }
 
-void UpdateMessage(::google::protobuf::Message* message, int32_t value) {
+void UpdateMessage(google::protobuf::Message* message, int32_t value) {
   auto* f = message->GetDescriptor()->FindFieldByName("value");
   if (!f) f = message->GetDescriptor()->FindFieldByName("int_value");
   if (!f) return;
   message->GetReflection()->SetInt32(message, f, value);
 }
 
-bool CheckMessage(const ::google::protobuf::Message& message, int32_t value) {
+bool CheckMessage(const google::protobuf::Message& message, int32_t value) {
   auto* f = message.GetDescriptor()->FindFieldByName("value");
   if (!f) f = message.GetDescriptor()->FindFieldByName("int_value");
   if (!f) return false;
   return message.GetReflection()->GetInt32(message, f) == value;
 }
 
-std::unique_ptr<::google::protobuf::Message> GetDynamicMessage(const std::string& full_name,
+std::unique_ptr<google::protobuf::Message> GetDynamicMessage(const std::string& full_name,
                                                    int32_t value) {
-  static ::google::protobuf::DynamicMessageFactory factory(GetDynamicPool());
+  static google::protobuf::DynamicMessageFactory factory(GetDynamicPool());
 
   auto* descriptor = GetDynamicPool()->FindMessageTypeByName(full_name);
   if (!descriptor) return nullptr;
@@ -76,7 +78,7 @@ std::unique_ptr<::google::protobuf::Message> GetDynamicMessage(const std::string
   auto* prototype = factory.GetPrototype(descriptor);
   if (!prototype) return nullptr;
 
-  std::unique_ptr<::google::protobuf::Message> dynamic(prototype->New());
+  std::unique_ptr<google::protobuf::Message> dynamic(prototype->New());
   UpdateMessage(dynamic.get(), value);
   return dynamic;
 }
@@ -87,21 +89,21 @@ PYBIND11_MODULE(dynamic_message_module, m) {
   //  Message building methods.
   m.def(
       "dynamic_message_ptr",
-      [](std::string name, int32_t value) -> ::google::protobuf::Message* {
+      [](std::string name, int32_t value) -> google::protobuf::Message* {
         return GetDynamicMessage(name, value).release();
       },
       py::arg("name") = "pybind11.test.DynamicMessage", py::arg("value") = 123);
 
   m.def(
       "dynamic_message_unique_ptr",
-      [](std::string name, int32_t value) -> std::unique_ptr<::google::protobuf::Message> {
+      [](std::string name, int32_t value) -> std::unique_ptr<google::protobuf::Message> {
         return GetDynamicMessage(name, value);
       },
       py::arg("name") = "pybind11.test.DynamicMessage", py::arg("value") = 123);
 
   m.def(
       "dynamic_message_shared_ptr",
-      [](std::string name, int32_t value) -> std::shared_ptr<::google::protobuf::Message> {
+      [](std::string name, int32_t value) -> std::shared_ptr<google::protobuf::Message> {
         return GetDynamicMessage(name, value);
       },
       py::arg("name") = "pybind11.test.DynamicMessage", py::arg("value") = 123);
@@ -110,7 +112,7 @@ PYBIND11_MODULE(dynamic_message_module, m) {
   m.def("check_message", &CheckMessage, py::arg("message"), py::arg("value"));
   m.def(
       "check_message_const_ptr",
-      [](const ::google::protobuf::Message* m, int value) {
+      [](const google::protobuf::Message* m, int value) {
         return (m == nullptr) ? false : CheckMessage(*m, value);
       },
       py::arg("message"), py::arg("value"));
@@ -118,19 +120,19 @@ PYBIND11_MODULE(dynamic_message_module, m) {
 #if PYBIND11_PROTOBUF_UNSAFE
   m.def(
       "mutate_message",
-      [](::google::protobuf::Message* msg, int value) { UpdateMessage(msg, value); },
+      [](google::protobuf::Message* msg, int value) { UpdateMessage(msg, value); },
       py::arg("message"), py::arg("value"));
 
   m.def(
       "mutate_message_ref",
-      [](::google::protobuf::Message& msg, int value) { UpdateMessage(&msg, value); },
+      [](google::protobuf::Message& msg, int value) { UpdateMessage(&msg, value); },
       py::arg("message"), py::arg("value"));
 #endif  // PYBIND11_PROTOBUF_UNSAFE
 
   // copies
   m.def(
       "roundtrip",
-      [](const ::google::protobuf::Message& inout) -> const ::google::protobuf::Message& {
+      [](const google::protobuf::Message& inout) -> const google::protobuf::Message& {
         return inout;
       },
       py::arg("message"), py::return_value_policy::copy);
@@ -138,11 +140,11 @@ PYBIND11_MODULE(dynamic_message_module, m) {
   // parse
   m.def(
       "parse_as",
-      [](std::string data, std::unique_ptr<::google::protobuf::Message> msg)
-          -> std::unique_ptr<::google::protobuf::Message> {
+      [](std::string data, std::unique_ptr<google::protobuf::Message> msg)
+          -> std::unique_ptr<google::protobuf::Message> {
         assert(msg.get());
         assert(msg->GetDescriptor());
-        ::google::protobuf::TextFormat::Parser parser;
+        google::protobuf::TextFormat::Parser parser;
         parser.ParseFromString(data, msg.get());
         return msg;
       },
@@ -150,10 +152,10 @@ PYBIND11_MODULE(dynamic_message_module, m) {
 
   m.def(
       "print",
-      [](std::unique_ptr<::google::protobuf::Message> msg) -> std::string {
+      [](std::unique_ptr<google::protobuf::Message> msg) -> std::string {
         std::string message;
         if (msg) {
-          ::google::protobuf::TextFormat::PrintToString(*msg, &message);
+          google::protobuf::TextFormat::PrintToString(*msg, &message);
         } else {
           message = "<nullptr>";
         }
@@ -163,7 +165,7 @@ PYBIND11_MODULE(dynamic_message_module, m) {
 
   m.def(
       "print_descriptor",
-      [](std::unique_ptr<::google::protobuf::Message> msg) -> std::string {
+      [](std::unique_ptr<google::protobuf::Message> msg) -> std::string {
         return (msg && msg->GetDescriptor())
                    ? msg->GetDescriptor()->DebugString()
                    : "<nullptr>";
diff --git a/pybind11_protobuf/tests/dynamic_message_test.py b/pybind11_protobuf/tests/dynamic_message_test.py
index d81ce61..0122338 100644
--- a/pybind11_protobuf/tests/dynamic_message_test.py
+++ b/pybind11_protobuf/tests/dynamic_message_test.py
@@ -10,10 +10,10 @@
 
 from absl.testing import absltest
 from absl.testing import parameterized
-
 from google.protobuf import descriptor_pb2
 from google.protobuf import descriptor_pool
 from google.protobuf import message_factory
+
 from pybind11_protobuf.tests import compare
 from pybind11_protobuf.tests import dynamic_message_module as m
 from pybind11_protobuf.tests import test_pb2
diff --git a/pybind11_protobuf/tests/message_module.cc b/pybind11_protobuf/tests/message_module.cc
index 61f5579..9b4ea20 100644
--- a/pybind11_protobuf/tests/message_module.cc
+++ b/pybind11_protobuf/tests/message_module.cc
@@ -5,9 +5,7 @@
 
 #include <pybind11/pybind11.h>
 
-#include <functional>
-#include <memory>
-#include <stdexcept>
+#include <string>
 
 #include "google/protobuf/message.h"
 #include "google/protobuf/text_format.h"
@@ -18,8 +16,8 @@ namespace py = ::pybind11;
 
 namespace {
 
-using pybind11::test::IntMessage;
-using pybind11::test::TestMessage;
+using ::pybind11::test::IntMessage;
+using ::pybind11::test::TestMessage;
 
 PYBIND11_MODULE(message_module, m) {
   pybind11_protobuf::ImportNativeProtoCasters();
@@ -56,7 +54,7 @@ nested {
       "make_test_message",
       [](std::string text) -> TestMessage {
         TestMessage msg;
-        if (!text.empty() && !::google::protobuf::TextFormat::ParseFromString(text, &msg)) {
+        if (!text.empty() && !google::protobuf::TextFormat::ParseFromString(text, &msg)) {
           throw py::value_error("Failed to parse text format TestMessage");
         }
         return msg;
diff --git a/pybind11_protobuf/tests/message_test.py b/pybind11_protobuf/tests/message_test.py
index a92caea..9873ebe 100644
--- a/pybind11_protobuf/tests/message_test.py
+++ b/pybind11_protobuf/tests/message_test.py
@@ -14,12 +14,12 @@
 
 from absl.testing import absltest
 from absl.testing import parameterized
+from google.protobuf import text_format
 
 from google.protobuf import any_pb2
 from pybind11_protobuf.tests import compare
 from pybind11_protobuf.tests import message_module as m
 from pybind11_protobuf.tests import test_pb2
-from google.protobuf import text_format
 
 
 def get_py_message():
diff --git a/pybind11_protobuf/tests/pass_by_module.cc b/pybind11_protobuf/tests/pass_by_module.cc
index b2c4ae8..b1ffa3a 100644
--- a/pybind11_protobuf/tests/pass_by_module.cc
+++ b/pybind11_protobuf/tests/pass_by_module.cc
@@ -6,13 +6,14 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include <cstdint>
 #include <functional>
 #include <memory>
-#include <stdexcept>
+#include <optional>
 #include <variant>
 
-#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/descriptor.h"
+#include "google/protobuf/descriptor.pb.h"
 #include "google/protobuf/dynamic_message.h"
 #include "google/protobuf/message.h"
 #include "pybind11_protobuf/native_proto_caster.h"
@@ -22,13 +23,13 @@ namespace py = ::pybind11;
 
 namespace {
 
-using pybind11::test::IntMessage;
+using ::pybind11::test::IntMessage;
 
 bool CheckIntMessage(const IntMessage* message, int32_t value) {
   return message ? message->value() == value : false;
 }
 
-bool CheckMessage(const ::google::protobuf::Message* message, int32_t value) {
+bool CheckMessage(const google::protobuf::Message* message, int32_t value) {
   if (!message) return false;
   auto* f = message->GetDescriptor()->FindFieldByName("value");
   if (!f) f = message->GetDescriptor()->FindFieldByName("int_value");
@@ -205,49 +206,49 @@ PYBIND11_MODULE(pass_by_module, m) {
   // abstract.
   m.def(
       "abstract_rval",
-      [](::google::protobuf::Message&& message, int value) {
+      [](google::protobuf::Message&& message, int value) {
         return CheckMessage(&message, value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_cref",
-      [](const ::google::protobuf::Message& message, int value) {
+      [](const google::protobuf::Message& message, int value) {
         return CheckMessage(&message, value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_cptr",
-      [](const ::google::protobuf::Message* message, int value) {
+      [](const google::protobuf::Message* message, int value) {
         return CheckMessage(message, value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_cptr_notnone",
-      [](const ::google::protobuf::Message* message, int value) {
+      [](const google::protobuf::Message* message, int value) {
         return CheckMessage(message, value);
       },
       py::arg("message").none(false), py::arg("value"));
   m.def(
       "abstract_uptr",
-      [](std::unique_ptr<::google::protobuf::Message> message, int value) {
+      [](std::unique_ptr<google::protobuf::Message> message, int value) {
         return CheckMessage(message.get(), value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_sptr",
-      [](std::shared_ptr<::google::protobuf::Message> message, int value) {
+      [](std::shared_ptr<google::protobuf::Message> message, int value) {
         return CheckMessage(message.get(), value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_csptr",
-      [](std::shared_ptr<const ::google::protobuf::Message> message, int value) {
+      [](std::shared_ptr<const google::protobuf::Message> message, int value) {
         return CheckMessage(message.get(), value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_cwref",
-      [](std::reference_wrapper<const ::google::protobuf::Message> message, int value) {
+      [](std::reference_wrapper<const google::protobuf::Message> message, int value) {
         return CheckMessage(&message.get(), value);
       },
       py::arg("message"), py::arg("value"));
@@ -255,25 +256,25 @@ PYBIND11_MODULE(pass_by_module, m) {
 #if PYBIND11_PROTOBUF_UNSAFE
   m.def(
       "abstract_ref",
-      [](::google::protobuf::Message& message, int value) {
+      [](google::protobuf::Message& message, int value) {
         return CheckMessage(&message, value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_ptr",
-      [](::google::protobuf::Message* message, int value) {
+      [](google::protobuf::Message* message, int value) {
         return CheckMessage(message, value);
       },
       py::arg("message"), py::arg("value"));
   m.def(
       "abstract_ptr_notnone",
-      [](::google::protobuf::Message* message, int value) {
+      [](google::protobuf::Message* message, int value) {
         return CheckMessage(message, value);
       },
       py::arg("message").none(false), py::arg("value"));
   m.def(
       "abstract_wref",
-      [](std::reference_wrapper<::google::protobuf::Message> message, int value) {
+      [](std::reference_wrapper<google::protobuf::Message> message, int value) {
         return CheckMessage(&message.get(), value);
       },
       py::arg("message"), py::arg("value"));
@@ -284,7 +285,7 @@ PYBIND11_MODULE(pass_by_module, m) {
       "fn_overload", [](const IntMessage&) -> int { return 2; },
       py::arg("message"));
   m.def(
-      "fn_overload", [](const ::google::protobuf::Message&) -> int { return 1; },
+      "fn_overload", [](const google::protobuf::Message&) -> int { return 1; },
       py::arg("message"));
 }
 
diff --git a/pybind11_protobuf/tests/pass_by_test.py b/pybind11_protobuf/tests/pass_by_test.py
index 56a69fc..49cc1a6 100644
--- a/pybind11_protobuf/tests/pass_by_test.py
+++ b/pybind11_protobuf/tests/pass_by_test.py
@@ -9,11 +9,11 @@
 
 from absl.testing import absltest
 from absl.testing import parameterized
+from google.protobuf import descriptor_pool
+from google.protobuf import message_factory
 
 from pybind11_protobuf.tests import pass_by_module as m
 from pybind11_protobuf.tests import test_pb2
-from google.protobuf import descriptor_pool
-from google.protobuf import message_factory
 
 
 def get_abstract_pass_by_params():
@@ -60,7 +60,7 @@ def get_pass_by_params():
       'concrete_uptr_ref',
       'concrete_wref',
       'std_variant',
-      'std_optional,'
+      'std_optional,',
   ]:
     try:
       p.append((x, getattr(m, x)))
@@ -115,7 +115,8 @@ def test_pool_proto_check(self, check_method):
     pool = descriptor_pool.Default()
     factory = message_factory.MessageFactory(pool)
     prototype = factory.GetPrototype(
-        pool.FindMessageTypeByName('pybind11.test.IntMessage'))
+        pool.FindMessageTypeByName('pybind11.test.IntMessage')
+    )
     message = prototype(value=9)
     self.assertTrue(check_method(message, 9))
 
diff --git a/pybind11_protobuf/tests/pass_proto2_message_module.cc b/pybind11_protobuf/tests/pass_proto2_message_module.cc
index c8c34b8..51f0c6e 100644
--- a/pybind11_protobuf/tests/pass_proto2_message_module.cc
+++ b/pybind11_protobuf/tests/pass_proto2_message_module.cc
@@ -14,8 +14,8 @@ PYBIND11_MODULE(pass_proto2_message_module, m) {
   pybind11_protobuf::ImportNativeProtoCasters();
 
   m.def("get_space_used_estimate",
-        [](const ::google::protobuf::Message& msg) -> std::size_t {
-          const ::google::protobuf::Reflection* refl = msg.GetReflection();
+        [](const google::protobuf::Message& msg) -> std::size_t {
+          const google::protobuf::Reflection* refl = msg.GetReflection();
           return refl != nullptr ? refl->SpaceUsedLong(msg) : 0;
         });
 }
diff --git a/pybind11_protobuf/tests/regression_wrappers_module.cc b/pybind11_protobuf/tests/regression_wrappers_module.cc
index 1c246cb..e9a7d35 100644
--- a/pybind11_protobuf/tests/regression_wrappers_module.cc
+++ b/pybind11_protobuf/tests/regression_wrappers_module.cc
@@ -5,7 +5,9 @@
 
 #include <pybind11/pybind11.h>
 
-#include "google/protobuf/descriptor.h"
+#include <memory>
+#include <string>
+
 #include "google/protobuf/message.h"
 #include "pybind11_protobuf/native_proto_caster.h"
 
@@ -15,7 +17,7 @@ PYBIND11_MODULE(regression_wrappers_module, m) {
   pybind11_protobuf::ImportNativeProtoCasters();
 
   m.def("print_descriptor_unique_ptr",
-        [](std::unique_ptr<::google::protobuf::Message> message) -> std::string {
+        [](std::unique_ptr<google::protobuf::Message> message) -> std::string {
           return message->GetDescriptor()->DebugString();
         });
 }
diff --git a/pybind11_protobuf/tests/wrapped_proto_module.cc b/pybind11_protobuf/tests/wrapped_proto_module.cc
index 3d7f0dc..015e238 100644
--- a/pybind11_protobuf/tests/wrapped_proto_module.cc
+++ b/pybind11_protobuf/tests/wrapped_proto_module.cc
@@ -6,14 +6,15 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
-#include <functional>
-#include <memory>
-#include <stdexcept>
+#include <cstdint>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
-#include "google/protobuf/dynamic_message.h"
+#include "absl/functional/function_ref.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
+#include "google/protobuf/dynamic_message.h"
 #include "pybind11_protobuf/tests/test.pb.h"
 #include "pybind11_protobuf/wrapped_proto_caster.h"
 
@@ -21,11 +22,11 @@ namespace py = ::pybind11;
 
 namespace {
 
-using pybind11::test::IntMessage;
-using pybind11::test::TestMessage;
-using pybind11_protobuf::WithWrappedProtos;
-using pybind11_protobuf::WrappedProto;
-using pybind11_protobuf::WrappedProtoKind;
+using ::pybind11::test::IntMessage;
+using ::pybind11::test::TestMessage;
+using ::pybind11_protobuf::WithWrappedProtos;
+using ::pybind11_protobuf::WrappedProto;
+using ::pybind11_protobuf::WrappedProtoKind;
 
 const TestMessage& GetStatic() {
   static TestMessage test_message = [] {
@@ -37,7 +38,7 @@ const TestMessage& GetStatic() {
   return test_message;
 }
 
-bool CheckMessage(const ::google::protobuf::Message* message, int32_t value) {
+bool CheckMessage(const google::protobuf::Message* message, int32_t value) {
   if (!message) return false;
   auto* f = message->GetDescriptor()->FindFieldByName("value");
   if (!f) f = message->GetDescriptor()->FindFieldByName("int_value");
diff --git a/pybind11_protobuf/wrapped_proto_caster.h b/pybind11_protobuf/wrapped_proto_caster.h
index 18cf7da..f2c295e 100644
--- a/pybind11_protobuf/wrapped_proto_caster.h
+++ b/pybind11_protobuf/wrapped_proto_caster.h
@@ -7,21 +7,18 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/pytypes.h>
 
-#include <functional>
 #include <memory>
-#include <optional>
-#include <string>
 #include <type_traits>
 #include <utility>
 
-#include "google/protobuf/message.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
+#include "google/protobuf/message.h"
 #include "pybind11_protobuf/proto_cast_util.h"
 #include "pybind11_protobuf/proto_caster_impl.h"
 
-// pybind11::type_caster<> specialization for ::google::protobuf::Message types using
-// pybind11_protobuf::WrappedProto<> wrappers. When passing from C++ to
+// pybind11::type_caster<> specialization for google::protobuf::Message types
+// using pybind11_protobuf::WrappedProto<> wrappers. When passing from C++ to
 // python a copy is always made. When passing from python to C++ a copy is
 // made for mutable and by-value types, but not for const reference types.
 //
@@ -68,10 +65,10 @@ inline void ImportWrappedProtoCasters() { InitializePybindProtoCastUtil(); }
 /// Tag types for WrappedProto specialization.
 enum WrappedProtoKind : int { kConst, kValue, kMutable };
 
-/// WrappedProto<T, kind> wraps a ::google::protobuf::Message subtype, exposing implicit
-/// constructors and implicit cast operators. The ConstTag variant allows
-/// conversion to const; the MutableTag allows mutable conversion and enables
-/// the type-caster specialization to enforce that a copy is made.
+/// WrappedProto<T, kind> wraps a google::protobuf::Message subtype, exposing
+/// implicit constructors and implicit cast operators. The ConstTag variant
+/// allows conversion to const; the MutableTag allows mutable conversion and
+/// enables the type-caster specialization to enforce that a copy is made.
 ///
 /// WrappedProto<T, kMutable> ALWAYS creates a copy.
 /// WrappedProto<T, kValue> ALWAYS creates a copy.
@@ -339,11 +336,11 @@ struct WrapHelper {
 template <typename ProtoType>
 struct WrapHelper<ProtoType,  //
                   std::enable_if_t<std::is_base_of<
-                      ::google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
+                      google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
   static constexpr auto kKind = DetectKind<ProtoType>();
   static_assert(kKind != WrappedProtoKind::kMutable,
-                "WithWrappedProtos() does not support mutable ::google::protobuf::Message "
-                "parameters.");
+                "WithWrappedProtos() does not support mutable "
+                "google::protobuf::Message parameters.");
 
   using type = WrappedProto<intrinsic_t<ProtoType>, kKind>;
 };
@@ -352,11 +349,11 @@ struct WrapHelper<ProtoType,  //
 template <typename ProtoType>
 struct WrapHelper<absl::optional<ProtoType>,  //
                   std::enable_if_t<std::is_base_of<
-                      ::google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
+                      google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
   static constexpr auto kKind = DetectKind<ProtoType>();
   static_assert(kKind != WrappedProtoKind::kMutable,
-                "WithWrappedProtos() does not support mutable ::google::protobuf::Message "
-                "parameters.");
+                "WithWrappedProtos() does not support mutable "
+                "google::protobuf::Message parameters.");
 
   using type = absl::optional<WrappedProto<intrinsic_t<ProtoType>, kKind>>;
 };
@@ -368,11 +365,11 @@ struct WrapHelper<absl::optional<ProtoType>,  //
 template <typename ProtoType>
 struct WrapHelper<absl::StatusOr<ProtoType>,  //
                   std::enable_if_t<std::is_base_of<
-                      ::google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
+                      google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
   static constexpr auto kKind = DetectKind<ProtoType>();
   static_assert(kKind != WrappedProtoKind::kMutable,
-                "WithWrappedProtos() does not support mutable ::google::protobuf::Message "
-                "parameters.");
+                "WithWrappedProtos() does not support mutable "
+                "google::protobuf::Message parameters.");
 
   using type = absl::StatusOr<WrappedProto<intrinsic_t<ProtoType>, kKind>>;
 };
@@ -382,13 +379,13 @@ struct WrapHelper<absl::StatusOr<ProtoType>,  //
 template <typename ProtoType>
 struct WrapHelper<std::vector<ProtoType>,  //
                   std::enable_if_t<std::is_base_of<
-                      ::google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
+                      google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
   using type = WrappedProtoVector<ProtoType>;
 };
 template <typename ProtoType>
 struct WrapHelper<const std::vector<ProtoType>&,  //
                   std::enable_if_t<std::is_base_of<
-                      ::google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
+                      google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
   using type = WrappedProtoVector<ProtoType>;
 };
 
@@ -396,13 +393,13 @@ struct WrapHelper<const std::vector<ProtoType>&,  //
 template <typename ProtoType>
 struct WrapHelper<absl::StatusOr<std::vector<ProtoType>>,  //
                   std::enable_if_t<std::is_base_of<
-                      ::google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
+                      google::protobuf::Message, intrinsic_t<ProtoType>>::value>> {
   using type = absl::StatusOr<WrappedProtoVector<ProtoType>>;
 };
 
 /// FunctionInvoker/ConstMemberInvoker/MemberInvoker are internal functions
-/// that expose calls with equivalent signatures, replacing ::google::protobuf::Message
-/// derived types with WrappedProto<T, ...> types.
+/// that expose calls with equivalent signatures, replacing
+/// google::protobuf::Message derived types with WrappedProto<T, ...> types.
 template <typename F, typename>
 struct FunctionInvoker;
 
@@ -426,7 +423,7 @@ struct FunctionInvoker<F, R(Args...) const> {
 
 template <typename C, typename R, typename... Args>
 struct ConstMemberInvoker {
-  static_assert(!std::is_base_of<::google::protobuf::Message, C>::value,
+  static_assert(!std::is_base_of<google::protobuf::Message, C>::value,
                 "WithWrappedProtos should not be used on methods generated by "
                 "the protocol buffer compiler");
 
@@ -439,7 +436,7 @@ struct ConstMemberInvoker {
 
 template <typename C, typename R, typename... Args>
 struct MemberInvoker {
-  static_assert(!std::is_base_of<::google::protobuf::Message, C>::value,
+  static_assert(!std::is_base_of<google::protobuf::Message, C>::value,
                 "WithWrappedProtos should not be used on methods generated by "
                 "the protocol buffer compiler");
 
@@ -464,8 +461,8 @@ struct LambdaSignature<U T::*> {
 }  // namespace impl
 
 /// WithWrappedProtos(...) wraps a function type and converts any
-/// ::google::protobuf::Message derived types into a WrappedProto<...> of the same
-/// underlying proto2 type.
+/// google::protobuf::Message derived types into a WrappedProto<...> of the
+/// same underlying proto2 type.
 template <typename F, int&... ExplicitArgumentBarrier,
           typename S = impl::LambdaSignature<decltype(&F::operator())>>
 auto WithWrappedProtos(F f) ->
@@ -500,7 +497,7 @@ namespace detail {
 template <typename ProtoType, pybind11_protobuf::WrappedProtoKind Kind>
 struct type_caster<
     pybind11_protobuf::WrappedProto<ProtoType, Kind>,
-    std::enable_if_t<std::is_base_of<::google::protobuf::Message, ProtoType>::value>>
+    std::enable_if_t<std::is_base_of<google::protobuf::Message, ProtoType>::value>>
     : public pybind11_protobuf::wrapped_proto_caster<
           pybind11_protobuf::WrappedProto<ProtoType, Kind>> {};
 
@@ -508,7 +505,7 @@ struct type_caster<
 template <typename ProtoType>
 struct type_caster<
     pybind11_protobuf::WrappedProtoVector<ProtoType>,
-    std::enable_if_t<std::is_base_of<::google::protobuf::Message, ProtoType>::value>>
+    std::enable_if_t<std::is_base_of<google::protobuf::Message, ProtoType>::value>>
     : public pybind11_protobuf::wrapped_proto_vector_caster<ProtoType> {};
 
 }  // namespace detail