remove unneeded .. code-block:: python

timgraham · timgraham · commit 479bf874a2bc · 2025-10-30T20:12:10.000-04:00
diff --git a/docs/howto/queryable-encryption.rst b/docs/howto/queryable-encryption.rst
@@ -15,18 +15,15 @@ Encryption in your Django project.
 
     Queryable Encryption can be used with MongoDB replica sets or sharded
     clusters running version 8.0 or later. Standalone instances are not
-    supported. The following table summarizes which MongoDB server products
-    support each Queryable Encryption mechanism.
-
-    - :ref:`manual:qe-compatibility-reference`
+    supported. The :ref:`manual:qe-compatibility-reference` table summarizes
+    which MongoDB server products support Queryable Encryption.
 
 Installation
 ============
 
-In addition to the :doc:`installation </intro/install>` and :doc:`configuration
-</intro/configure>` steps required to use Django MongoDB Backend, Queryable
-Encryption has additional dependencies. You can install these dependencies
-by using the ``encryption`` extra when installing ``django-mongodb-backend``:
+In addition to Django MongoDB Backend's regular :doc:`installation
+</intro/install>` and :doc:`configuration </intro/configure>` steps, Queryable
+Encryption has additional Python dependencies:
 
 .. code-block:: console
 
@@ -49,13 +46,8 @@ configure a separate encrypted database connection in your
     :class:`automatic encryption
     <pymongo.encryption_options.AutoEncryptionOpts>`.
 
-The following example shows how to
-configure an encrypted database using the :class:`AutoEncryptionOpts
-<pymongo.encryption_options.AutoEncryptionOpts>` from the
-:mod:`encryption_options <pymongo.encryption_options>` module with a local KMS
-provider and encryption keys stored in the ``encryption.__keyVault`` collection.
-
-.. code-block:: python
+Here's how to configure an encrypted database using a local KMS provider and
+encryption keys stored in the ``encryption.__keyVault`` collection::
 
     import os
 
@@ -104,10 +96,7 @@ route database operations to the encrypted database.
 
 The following example shows how to configure a router for the "myapp"
 application that routes database operations to the encrypted database for all
-models in that application. The router also specifies the :ref:`KMS provider
-<qe-configuring-kms>` to use.
-
-.. code-block:: python
+models in that application::
 
     # myapp/routers.py
     class EncryptedRouter:
@@ -127,9 +116,7 @@ models in that application. The router also specifies the :ref:`KMS provider
         db_for_write = db_for_read
 
 Then in your Django settings, add the custom database router to the
-:setting:`django:DATABASE_ROUTERS` setting:
-
-.. code-block:: python
+:setting:`django:DATABASE_ROUTERS` setting::
 
     # settings.py
     DATABASE_ROUTERS = ["myapp.routers.EncryptedRouter"]
@@ -162,9 +149,7 @@ options followed by an example of how to use them.
 +-------------------------------------------------------------------------+--------------------------------------------------------+
 
 Example of KMS configuration with ``aws`` in your :class:`kms_providers
-<pymongo.encryption_options.AutoEncryptionOpts>` setting:
-
-.. code-block:: python
+<pymongo.encryption_options.AutoEncryptionOpts>` setting::
 
     from pymongo.encryption_options import AutoEncryptionOpts
 
@@ -223,12 +208,10 @@ Django MongoDB Backend, along with the entire schema, you can run the
 
 Use the output of :djadmin:`showencryptedfieldsmap` to set the
 ``encrypted_fields_map`` in :class:`AutoEncryptionOpts
-<pymongo.encryption_options.AutoEncryptionOpts>` in your Django settings.
-
-.. code-block:: python
+<pymongo.encryption_options.AutoEncryptionOpts>` in your Django settings::
 
-    from pymongo.encryption_options import AutoEncryptionOpts
     from bson import json_util
+    from pymongo.encryption_options import AutoEncryptionOpts
 
     DATABASES = {
         "encrypted": {
@@ -239,30 +222,28 @@ Use the output of :djadmin:`showencryptedfieldsmap` to set the
                     encrypted_fields_map=json_util.loads(
                         """{
                         "encrypt_patient": {
-                          "fields": [
-                            {
-                              "bsonType": "string",
-                              "path": "patient_record.ssn",
-                              "keyId": {
-                                "$binary": {
-                                  "base64": "2MA29LaARIOqymYHGmi2mQ==",
-                                  "subType": "04"
-                                }
-                              },
-                              "queries": {
-                                "queryType": "equality"
-                              }
-                            },
-                          ]
-                        }
-                    }"""
+                            "fields": [
+                                 {
+                                     "bsonType": "string",
+                                     "path": "patient_record.ssn",
+                                     "keyId": {
+                                          "$binary": {
+                                              "base64": "2MA29LaARIOqymYHGmi2mQ==",
+                                              "subType": "04"
+                                          }
+                                     },
+                                     "queries": {
+                                         "queryType": "equality"
+                                     }
+                                 },
+                            ]
+                        }}"""
                     ),
-                )
+                ),
             },
         },
     }
 
-
 .. admonition:: Security consideration
 
    Supplying an encrypted fields map provides more security than relying on an
@@ -287,9 +268,7 @@ settings using the ``crypt_shared_lib_path`` option in
 :class:`AutoEncryptionOpts <pymongo.encryption_options.AutoEncryptionOpts>`.
 
 The following example shows how to configure the shared library in your Django
-settings:
-
-.. code-block:: python
+settings::
 
     from pymongo.encryption_options import AutoEncryptionOpts
 
diff --git a/docs/topics/queryable-encryption.rst b/docs/topics/queryable-encryption.rst
@@ -21,10 +21,7 @@ queries on certain encrypted fields. To use encrypted fields in your models,
 import the necessary field types from ``django_mongodb_backend.models`` and
 define your models as usual.
 
-Here's the `Python Queryable Encryption Tutorial`_ example implemented in
-Django:
-
-.. code-block:: python
+Here are models based on the `Python Queryable Encryption Tutorial`_::
 
     # myapp/models.py
     from django.db import models
@@ -55,6 +52,8 @@ Django:
         cc_type = models.CharField(max_length=50)
         cc_number = models.CharField(max_length=20)
 
+.. _Python Queryable Encryption Tutorial: https://github.com/mongodb/docs/tree/main/content/manual/manual/source/includes/qe-tutorials/python
+
 .. _qe-migrations:
 
 Migrations
@@ -84,25 +83,20 @@ The example above requires a :ref:`database router
 <qe-configuring-database-routers-setting>` to direct operations on models with
 encrypted fields to the appropriate database. It also requires the use of a
 :ref:`router for embedded models <configuring-database-routers-setting>`. Here
-is an example that includes both:
-
-.. code-block:: python
+is an example that includes both::
 
     # myproject/settings.py
     DATABASE_ROUTERS = [
         "django_mongodb_backend.routers.MongoRouter",
         "myproject.routers.EncryptedRouter",
     ]
 
-
 Querying encrypted fields
 -------------------------
 
 In order to query encrypted fields, you must define the queryable encryption
 query type in the model field definition. For example, if you want to query the
-``ssn`` field for equality, you can define it as follows:
-
-.. code-block:: python
+``ssn`` field for equality, you can define it as follows::
 
     class PatientRecord(EmbeddedModel):
         ssn = EncryptedCharField(max_length=11, queries={"queryType": "equality"})
@@ -137,30 +131,10 @@ supports:
     perform comparisons on encrypted fields, while Django's range lookups are
     used for filtering based on a range of values.
 
-If you have an encrypted field that supports range queries like this:
-
-.. code-block:: python
-
-    class PatientRecord(EmbeddedModel):
-        ssn = EncryptedCharField(max_length=11, queries={"queryType": "range"})
-        billing = EncryptedEmbeddedModelField("Billing")
-        bill_amount = models.DecimalField(max_digits=10, decimal_places=2)
-
-You can perform a query like this:
-
-.. code-block:: console
-
-    >>> patients = Patient.objects.filter(patient_record__ssn__gte="123-45-0000",
-    ...                                    patient_record__ssn__lte="123-45-9999")
-
-This will return all patients whose SSN falls within the specified range.
-
 QuerySet limitations
 ~~~~~~~~~~~~~~~~~~~~
 
 In addition to :ref:`Django MongoDB Backend's QuerySet limitations
 <known-issues-limitations-querying>`,
 
 .. TODO
-
-.. _Python Queryable Encryption Tutorial: https://github.com/mongodb/docs/tree/main/content/manual/manual/source/includes/qe-tutorials/python
