Merge branch 'master' of github.com:mongodb/mongo-python-driver

Author: blink1073

.github/workflows/codeql.yml

@@ -46,7 +46,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3
+      uses: github/codeql-action/init@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
@@ -63,6 +63,6 @@ jobs:
         pip install -e .
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3
+      uses: github/codeql-action/analyze@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3
       with:
         category: "/language:${{matrix.language}}"

.github/workflows/zizmor.yml

@@ -26,7 +26,7 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3
+        uses: github/codeql-action/upload-sarif@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3
         with:
           sarif_file: results.sarif
           category: zizmor

CONTRIBUTING.md

@@ -384,7 +384,14 @@ If you are running one of the `no-responder` tests, omit the `run-server` step.
 - Regenerate the test variants and tasks using `pre-commit run --all-files generate-config`.
 - Make sure to add instructions for running the test suite to `CONTRIBUTING.md`.
 
-## Re-sync Spec Tests
+## Specification Tests
+
+The MongoDB [specifications repository](https://github.com/mongodb/specifications)
+holds in progress and completed specifications for features of MongoDB, drivers,
+and associated products. PyMongo supports the [Unified Test Format](https://jira.mongodb.org/browse/DRIVERS-709)
+for running specification tests to confirm PyMongo behaves as expected.
+
+### Resynchronizing the Specification Tests
 
 If you would like to re-sync the copy of the specification tests in the
 PyMongo repository with that which is inside the [specifications

_setup.py

@@ -130,7 +130,11 @@ def build_extension(self, ext):
     except ValueError:
         pass
     ext_modules = []
-elif sys.platform.startswith("java") or sys.platform == "cli" or "PyPy" in sys.version:
+elif (
+    sys.platform.startswith("java")
+    or sys.platform == "cli"
+    or sys.implementation.name in ("pypy", "graalpy")
+):
     sys.stdout.write(
         """
 *****************************************************\n

bson/codec_options.py

@@ -160,6 +160,16 @@ def __init__(
                     f"Expected an instance of {TypeEncoder.__name__}, {TypeDecoder.__name__}, or {TypeCodec.__name__}, got {codec!r} instead"
                 )
 
+    @property
+    def codecs(self) -> list[TypeEncoder | TypeDecoder | TypeCodec]:
+        """The list of type codecs in this registry."""
+        return self.__type_codecs
+
+    @property
+    def fallback_encoder(self) -> Optional[_Fallback]:
+        """The fallback encoder in this registry."""
+        return self._fallback_encoder
+
     def _validate_type_encoder(self, codec: _Codec) -> None:
         from bson import _BUILT_IN_TYPES
 

doc/changelog.rst

@@ -1,6 +1,13 @@
 Changelog
 =========
 
+Changes in Version 4.14.0 (XXXX/XX/XX)
+--------------------------------------
+PyMongo 4.14 brings a number of changes including:
+
+- Added :attr:`bson.codec_options.TypeRegistry.codecs` and :attr:`bson.codec_options.TypeRegistry.fallback_encoder` properties
+  to allow users to directly access the type codecs and fallback encoder for a given :class:`bson.codec_options.TypeRegistry`.
+
 Changes in Version 4.13.0 (2025/05/14)
 --------------------------------------
 

test/asynchronous/test_bulk.py

@@ -94,7 +94,7 @@ def assertEqualUpsert(self, expected, actual):
         self.assertEqual(expected["index"], actual["index"])
         if expected["_id"] == "...":
             # Unspecified value.
-            self.assertTrue("_id" in actual)
+            self.assertIn("_id", actual)
         else:
             self.assertEqual(expected["_id"], actual["_id"])
 
@@ -107,15 +107,15 @@ def assertEqualWriteError(self, expected, actual):
         self.assertEqual(expected["code"], actual["code"])
         if expected["errmsg"] == "...":
             # Unspecified value.
-            self.assertTrue("errmsg" in actual)
+            self.assertIn("errmsg", actual)
         else:
             self.assertEqual(expected["errmsg"], actual["errmsg"])
 
         expected_op = expected["op"].copy()
         actual_op = actual["op"].copy()
         if expected_op.get("_id") == "...":
             # Unspecified _id.
-            self.assertTrue("_id" in actual_op)
+            self.assertIn("_id", actual_op)
             actual_op.pop("_id")
             expected_op.pop("_id")
 
@@ -160,7 +160,7 @@ async def _test_update_many(self, update):
         result = await self.coll.bulk_write([UpdateMany({}, update)])
         self.assertEqualResponse(expected, result.bulk_api_result)
         self.assertEqual(2, result.matched_count)
-        self.assertTrue(result.modified_count in (2, None))
+        self.assertIn(result.modified_count, (2, None))
 
     async def test_update_many(self):
         await self._test_update_many({"$set": {"foo": "bar"}})
@@ -201,7 +201,7 @@ async def _test_update_one(self, update):
         result = await self.coll.bulk_write([UpdateOne({}, update)])
         self.assertEqualResponse(expected, result.bulk_api_result)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (1, None))
+        self.assertIn(result.modified_count, (1, None))
 
     async def test_update_one(self):
         await self._test_update_one({"$set": {"foo": "bar"}})
@@ -227,7 +227,7 @@ async def test_replace_one(self):
         result = await self.coll.bulk_write([ReplaceOne({}, {"foo": "bar"})])
         self.assertEqualResponse(expected, result.bulk_api_result)
         self.assertEqual(1, result.matched_count)
-        self.assertTrue(result.modified_count in (1, None))
+        self.assertIn(result.modified_count, (1, None))
 
     async def test_remove(self):
         # Test removing all documents, ordered.
@@ -281,7 +281,7 @@ async def test_upsert(self):
         self.assertEqual(1, result.upserted_count)
         assert result.upserted_ids is not None
         self.assertEqual(1, len(result.upserted_ids))
-        self.assertTrue(isinstance(result.upserted_ids.get(0), ObjectId))
+        self.assertIsInstance(result.upserted_ids.get(0), ObjectId)
 
         self.assertEqual(await self.coll.count_documents({"foo": "bar"}), 1)
 
@@ -998,7 +998,7 @@ async def test_write_concern_failure_ordered(self):
 
         failed = details["writeConcernErrors"][0]
         self.assertEqual(64, failed["code"])
-        self.assertTrue(isinstance(failed["errmsg"], str))
+        self.assertIsInstance(failed["errmsg"], str)
 
         await self.coll.delete_many({})
         await self.coll.create_index("a", unique=True)
@@ -1037,7 +1037,7 @@ async def test_write_concern_failure_ordered(self):
 
         self.assertTrue(len(details["writeConcernErrors"]) > 1)
         failed = details["writeErrors"][0]
-        self.assertTrue("duplicate" in failed["errmsg"])
+        self.assertIn("duplicate", failed["errmsg"])
 
     @async_client_context.require_version_max(7, 1)  # PYTHON-4560
     @async_client_context.require_replica_set
@@ -1105,12 +1105,12 @@ async def test_write_concern_failure_unordered(self):
         failed = details["writeErrors"][0]
         self.assertEqual(2, failed["index"])
         self.assertEqual(11000, failed["code"])
-        self.assertTrue(isinstance(failed["errmsg"], str))
+        self.assertIsInstance(failed["errmsg"], str)
         self.assertEqual(1, failed["op"]["a"])
 
         failed = details["writeConcernErrors"][0]
         self.assertEqual(64, failed["code"])
-        self.assertTrue(isinstance(failed["errmsg"], str))
+        self.assertIsInstance(failed["errmsg"], str)
 
         upserts = details["upserted"]
         self.assertEqual(1, len(upserts))

test/asynchronous/test_client.py

@@ -214,7 +214,7 @@ def make_db(base, name):
         self.assertRaises(InvalidName, make_db, self.client, "te/t")
         self.assertRaises(InvalidName, make_db, self.client, "te st")
 
-        self.assertTrue(isinstance(self.client.test, AsyncDatabase))
+        self.assertIsInstance(self.client.test, AsyncDatabase)
         self.assertEqual(self.client.test, self.client["test"])
         self.assertEqual(self.client.test, AsyncDatabase(self.client, "test"))
 
@@ -228,7 +228,7 @@ def test_get_database(self):
         self.assertEqual(write_concern, db.write_concern)
 
     def test_getattr(self):
-        self.assertTrue(isinstance(self.client["_does_not_exist"], AsyncDatabase))
+        self.assertIsInstance(self.client["_does_not_exist"], AsyncDatabase)
 
         with self.assertRaises(AttributeError) as context:
             self.client._does_not_exist
@@ -674,7 +674,7 @@ async def test_max_idle_time_reaper_default(self):
             async with server._pool.checkout() as conn:
                 pass
             self.assertEqual(1, len(server._pool.conns))
-            self.assertTrue(conn in server._pool.conns)
+            self.assertIn(conn, server._pool.conns)
 
     async def test_max_idle_time_reaper_removes_stale_minPoolSize(self):
         with client_knobs(kill_cursor_frequency=0.1):
@@ -752,7 +752,7 @@ async def test_min_pool_size(self):
                 lambda: len(server._pool.conns) == 10,
                 "a closed socket gets replaced from the pool",
             )
-            self.assertFalse(conn in server._pool.conns)
+            self.assertNotIn(conn, server._pool.conns)
 
     async def test_max_idle_time_checkout(self):
         # Use high frequency to test _get_socket_no_auth.
@@ -769,8 +769,8 @@ async def test_max_idle_time_checkout(self):
             async with server._pool.checkout() as new_con:
                 self.assertNotEqual(conn, new_con)
             self.assertEqual(1, len(server._pool.conns))
-            self.assertFalse(conn in server._pool.conns)
-            self.assertTrue(new_con in server._pool.conns)
+            self.assertNotIn(conn, server._pool.conns)
+            self.assertIn(new_con, server._pool.conns)
 
             # Test that connections are reused if maxIdleTimeMS is not set.
             client = await self.async_rs_or_single_client()
@@ -1032,8 +1032,8 @@ async def test_list_database_names(self):
         cmd_names = [doc["name"] for doc in cmd_docs]
 
         db_names = await self.client.list_database_names()
-        self.assertTrue("pymongo_test" in db_names)
-        self.assertTrue("pymongo_test_mike" in db_names)
+        self.assertIn("pymongo_test", db_names)
+        self.assertIn("pymongo_test_mike", db_names)
         self.assertEqual(db_names, cmd_names)
 
     async def test_drop_database(self):
@@ -1257,9 +1257,9 @@ async def test_unix_socket(self):
         client = await self.async_rs_or_single_client(uri)
         await client.pymongo_test.test.insert_one({"dummy": "object"})
         dbs = await client.list_database_names()
-        self.assertTrue("pymongo_test" in dbs)
+        self.assertIn("pymongo_test", dbs)
 
-        self.assertTrue(mongodb_socket in repr(client))
+        self.assertIn(mongodb_socket, repr(client))
 
         # Confirm it fails with a missing socket.
         with self.assertRaises(ConnectionFailure):
@@ -1274,15 +1274,15 @@ async def test_document_class(self):
         await db.test.insert_one({"x": 1})
 
         self.assertEqual(dict, c.codec_options.document_class)
-        self.assertTrue(isinstance(await db.test.find_one(), dict))
-        self.assertFalse(isinstance(await db.test.find_one(), SON))
+        self.assertIsInstance(await db.test.find_one(), dict)
+        self.assertNotIsInstance(await db.test.find_one(), SON)
 
         c = await self.async_rs_or_single_client(document_class=SON)
 
         db = c.pymongo_test
 
         self.assertEqual(SON, c.codec_options.document_class)
-        self.assertTrue(isinstance(await db.test.find_one(), SON))
+        self.assertIsInstance(await db.test.find_one(), SON)
 
     async def test_timeouts(self):
         client = await self.async_rs_or_single_client(
@@ -1431,8 +1431,8 @@ async def test_ipv6(self):
         await client.pymongo_test_bernie.test.insert_one({"dummy": "object"})
 
         dbs = await client.list_database_names()
-        self.assertTrue("pymongo_test" in dbs)
-        self.assertTrue("pymongo_test_bernie" in dbs)
+        self.assertIn("pymongo_test", dbs)
+        self.assertIn("pymongo_test_bernie", dbs)
 
     async def test_contextlib(self):
         client = await self.async_rs_or_single_client()