From 62cfd1fcfb6431b3fb3d87b03c5e6374e719e720 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Tue, 7 Apr 2026 21:46:40 +0300
Subject: [PATCH 01/49] tests: detect stale Cython extensions at test startup

Add a pytest_configure hook in tests/conftest.py that compares mtime
of each compiled extension against its .py source and warns when the
source is newer. This prevents silently testing stale compiled code
after editing a Cython-compiled module without rebuilding.

The scan iterates over .py source files and checks for the first
matching compiled extension per importlib.machinery.EXTENSION_SUFFIXES
order, mirroring Python's import machinery and handling both .so (POSIX)
and .pyd (Windows) automatically.

Also document the rebuild requirement in CONTRIBUTING.rst, using uv
commands instead of deprecated setup.py invocations.
---
 CONTRIBUTING.rst  | 13 +++++++++
 tests/conftest.py | 67 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 80 insertions(+)
 create mode 100644 tests/conftest.py

diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index 8b8fc0e791..82bf21e52f 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -40,6 +40,19 @@ When modifying driver files, rebuilding Cython modules is often necessary.
 Without caching, each such rebuild may take over a minute. Caching usually brings it
 down to about 2-3 seconds.
 
+**Important:** After modifying any ``.py`` file under ``cassandra/`` that is
+Cython-compiled (such as ``query.py``, ``protocol.py``, ``cluster.py``, etc.),
+extensions must be rebuilt before running tests. If you always use ``uv run``
+(e.g. ``uv run pytest``), this is handled automatically via the ``cache-keys``
+configuration in ``pyproject.toml``. If you invoke ``pytest`` directly, you can
+rebuild with::
+
+    uv sync --reinstall-package scylla-driver
+
+Without rebuilding, Python will load the stale compiled extension (``.so`` / ``.pyd``)
+instead of your modified ``.py`` source, and your changes will not actually be tested.
+The test suite will emit a warning if it detects this situation.
+
 Building the Docs
 =================
 
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000000..8fd2fc923b
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,67 @@
+# Copyright ScyllaDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib.machinery
+import os
+import warnings
+
+# Directory containing the Cython-compiled driver modules.
+_CASSANDRA_DIR = os.path.join(os.path.dirname(__file__), os.pardir, "cassandra")
+
+
+def pytest_configure(config):
+    """Warn when a compiled Cython extension is older than its .py source.
+
+    Python's import system prefers compiled extensions (.so / .pyd) over pure
+    Python (.py) files.  If a developer edits a .py file without rebuilding
+    the Cython extensions, the tests
+    will silently run the *old* compiled code, masking any regressions in the
+    Python source.
+
+    This hook detects such staleness at test-session startup so the developer
+    is alerted immediately.
+    """
+    stale = []
+    # Iterate over .py sources and, for each module, look for the first
+    # existing compiled extension in EXTENSION_SUFFIXES order.  This mirrors
+    # how Python's import machinery selects an extension module, and avoids
+    # globbing patterns like "*{suffix}" that can pick up ABI-tagged
+    # extensions built for other Python versions.
+    if os.path.isdir(_CASSANDRA_DIR):
+        for entry in os.listdir(_CASSANDRA_DIR):
+            if not entry.endswith(".py"):
+                continue
+            module_name, _ = os.path.splitext(entry)
+            py_path = os.path.join(_CASSANDRA_DIR, entry)
+            # For this module, find the first extension file Python would load.
+            for suffix in importlib.machinery.EXTENSION_SUFFIXES:
+                ext_path = os.path.join(_CASSANDRA_DIR, module_name + suffix)
+                if not os.path.exists(ext_path):
+                    continue
+                if os.path.getmtime(py_path) > os.path.getmtime(ext_path):
+                    stale.append((module_name, ext_path, py_path))
+                # Only consider the first matching suffix; this is the one
+                # the import system would actually use.
+                break
+
+    if stale:
+        names = ", ".join(m for m, _, _ in stale)
+        warnings.warn(
+            f"Stale Cython extension(s) detected: {names}. "
+            f"The .py source is newer than the compiled extension — tests "
+            f"will run the OLD compiled code, not your latest changes. "
+            f"Rebuild with:  uv sync --reinstall-package scylla-driver\n"
+            f"Or use 'uv run pytest' which handles rebuilds automatically.",
+            stacklevel=1,
+        )

From 442074c1743378d7cbc631be7fd137f636d7373f Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Tue, 7 Apr 2026 21:46:46 +0300
Subject: [PATCH 02/49] docs: replace direct setup.py invocations with pip in
 installation guide

Replace all 'python setup.py install' instructions with 'pip install .'
or 'pip install scylla-driver' equivalents. Replace setup.py-specific
command-line flags (--no-cython, --no-extensions, etc.) with their
environment variable equivalents (CASS_DRIVER_NO_CYTHON,
CASS_DRIVER_NO_EXTENSIONS, CASS_DRIVER_NO_LIBEV). Remove deprecated
pip --install-option usage.
---
 docs/installation.rst | 33 ++++++++++++---------------------
 1 file changed, 12 insertions(+), 21 deletions(-)

diff --git a/docs/installation.rst b/docs/installation.rst
index 7b4823b832..fbb9ac4043 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -62,9 +62,6 @@ threads used to build the driver and any C extensions:
 
 .. code-block:: bash
 
-    $ # installing from source
-    $ CASS_DRIVER_BUILD_CONCURRENCY=8 python setup.py install
-    $ # installing from pip
     $ CASS_DRIVER_BUILD_CONCURRENCY=8 pip install scylla-driver
 
 Note that by default (when CASS_DRIVER_BUILD_CONCURRENCY is not specified), concurrency will be equal to the number of
@@ -108,7 +105,7 @@ installed. You can find the list of dependencies in
 
 Once the dependencies are installed, simply run::
 
-    python setup.py install
+    pip install .
 
 
 (*Optional*) Non-python Dependencies
@@ -122,9 +119,9 @@ for token-aware routing with the ``Murmur3Partitioner``,
 `libev <http://software.schmorp.de/pkg/libev.html>`_ event loop integration,
 and Cython optimized extensions.
 
-When installing manually through setup.py, you can disable both with
-the ``--no-extensions`` option, or selectively disable them with
-with ``--no-murmur3``, ``--no-libev``, or ``--no-cython``.
+Extensions can be selectively disabled using environment variables:
+``CASS_DRIVER_NO_EXTENSIONS=1`` (disable all), ``CASS_DRIVER_NO_CYTHON=1``,
+or ``CASS_DRIVER_NO_LIBEV=1``.
 
 To compile the extensions, ensure that GCC and the Python headers are available.
 
@@ -149,31 +146,25 @@ This is not a hard requirement, but is engaged by default to build extensions of
 pure Python implementation.
 
 This is a costly build phase, especially in clean environments where the Cython compiler must be built
-This build phase can be avoided using the build switch, or an environment variable::
+This build phase can be avoided using an environment variable::
 
-    python setup.py install --no-cython
+    CASS_DRIVER_NO_CYTHON=1 pip install scylla-driver
 
-Alternatively, an environment variable can be used to switch this option regardless of
+Alternatively, the environment variable can be used to switch this option regardless of
 context::
 
     CASS_DRIVER_NO_CYTHON=1 <your script here>
     - or, to disable all extensions:
     CASS_DRIVER_NO_EXTENSIONS=1 <your script here>
 
-This method is required when using pip, which provides no other way of injecting user options in a single command::
-
-    CASS_DRIVER_NO_CYTHON=1 pip install scylla-driver
-    CASS_DRIVER_NO_CYTHON=1 sudo -E pip install ~/python-driver
-
-The environment variable is the preferred option because it spans all invocations of setup.py, and will
+These environment variables are the preferred option, and will
 prevent Cython from being materialized as a setup requirement.
 
-If your sudo configuration does not allow SETENV, you must push the option flag down via pip. However, pip
-applies these options to all dependencies (which break on the custom flag). Therefore, you must first install
-dependencies, then use install-option::
+If your sudo configuration does not allow SETENV, you must first install
+dependencies, then install the driver::
 
     sudo pip install futures
-    sudo pip install --install-option="--no-cython"
+    sudo CASS_DRIVER_NO_CYTHON=1 pip install scylla-driver
 
 
 Supported Event Loops
@@ -205,7 +196,7 @@ install libev using any Windows package manager.  For example, to install using
     $ vcpkg install libev
 
 If successful, you should be able to build and install the extension
-(just using ``setup.py build`` or ``setup.py install``) and then use
+(just using ``pip install .``) and then use
 the libev event loop by doing the following:
 
 .. code-block:: python

From ee98fd0413994ee31345db7db1e5f2b608418a74 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 11:14:12 +0300
Subject: [PATCH 03/49] tests: fix incorrect retry count in
 execute_with_long_wait_retry error message

The error message said 'Failed after 100 attempts' but the retry limit
is 10 (while tries < 10). This was a copy-paste error from
execute_until_pass() which does retry 100 times.
---
 tests/integration/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
index 2015e0663f..286561c291 100644
--- a/tests/integration/__init__.py
+++ b/tests/integration/__init__.py
@@ -600,7 +600,7 @@ def execute_with_long_wait_retry(session, query, timeout=30):
             del tb
             tries += 1
 
-    raise RuntimeError("Failed to execute query after 100 attempts: {0}".format(query))
+    raise RuntimeError("Failed to execute query after 10 attempts: {0}".format(query))
 
 
 def execute_with_retry_tolerant(session, query, retry_exceptions, escape_exception):

From f7890b912c7cebbbc8f4e16368bdb8091c96553b Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 11:20:03 +0300
Subject: [PATCH 04/49] tests: standardize test_cluster.py to --smp 2

Change test_cluster.py from --smp 1 to --smp 2 to match the standard
configuration used by other test files. This enables cluster topology
consolidation in a follow-up commit.
---
 tests/integration/standard/test_cluster.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/standard/test_cluster.py b/tests/integration/standard/test_cluster.py
index aab4131739..6db9657932 100644
--- a/tests/integration/standard/test_cluster.py
+++ b/tests/integration/standard/test_cluster.py
@@ -52,7 +52,7 @@
 
 
 def setup_module():
-    os.environ['SCYLLA_EXT_OPTS'] = "--smp 1"
+    os.environ['SCYLLA_EXT_OPTS'] = "--smp 2"
     use_cluster("cluster_tests", [3], start=True, workloads=None)
     warnings.simplefilter("always")
 

From aa0043a3add6829b8b6d5022be7357ef4b85bbfc Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 11:23:18 +0300
Subject: [PATCH 05/49] tests: consolidate cluster topologies to reduce cluster
 teardown/setup

Merge cluster names for test files with identical configurations:
- test_shard_aware.py: 'shard_aware' -> 'cluster_tests' (same --smp 2,
  3 nodes as test_cluster.py)
- test_client_routes.py: 'test_client_routes' -> 'shared_aware' (same
  --smp 2 --memory 2048M, 3 nodes as test_use_keyspace.py)

This allows the CCM cluster to be reused when these tests run
sequentially, avoiding a full cluster teardown and restart.

Also update conftest.py cleanup list to include 'cluster_tests' and
'test_client_routes_replacement' which were previously missing.
---
 tests/integration/conftest.py                    | 2 +-
 tests/integration/standard/test_client_routes.py | 2 +-
 tests/integration/standard/test_shard_aware.py   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index a682bcb608..5db8026675 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -17,7 +17,7 @@ def cleanup_clusters():
 
     if not os.environ.get('DISABLE_CLUSTER_CLEANUP'):
         for cluster_name in [CLUSTER_NAME, SINGLE_NODE_CLUSTER_NAME, MULTIDC_CLUSTER_NAME,
-                             'shared_aware', 'sni_proxy', 'test_ip_change']:
+                             'cluster_tests', 'shared_aware', 'sni_proxy', 'test_ip_change', 'test_client_routes_replacement']:
             try:
                 cluster = CCMClusterFactory.load(ccm_path, cluster_name)
                 logging.debug("Using external CCM cluster {0}".format(cluster.name))
diff --git a/tests/integration/standard/test_client_routes.py b/tests/integration/standard/test_client_routes.py
index 4e328df0c0..a799073e25 100644
--- a/tests/integration/standard/test_client_routes.py
+++ b/tests/integration/standard/test_client_routes.py
@@ -521,7 +521,7 @@ def assert_routes_direct(test, cluster, expected_node_ids, direct_port=9042):
 
 def setup_module():
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2 --memory 2048M"
-    use_cluster('test_client_routes', [3], start=True)
+    use_cluster('shared_aware', [3], start=True)
 
 @skip_scylla_version_lt(reason='scylladb/scylladb#26992 - system.client_routes is not yet supported',
                         scylla_version="2026.1.0")
diff --git a/tests/integration/standard/test_shard_aware.py b/tests/integration/standard/test_shard_aware.py
index 2d764d681e..0fdb9ed08d 100644
--- a/tests/integration/standard/test_shard_aware.py
+++ b/tests/integration/standard/test_shard_aware.py
@@ -33,7 +33,7 @@
 
 def setup_module():
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2"
-    use_cluster('shard_aware', [3], start=True)
+    use_cluster('cluster_tests', [3], start=True)
 
 
 class TestShardAwareIntegration(unittest.TestCase):

From dd15509a5c0463614eba7b2704e006edf5f3fc68 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 11:24:22 +0300
Subject: [PATCH 06/49] tests: add test ordering by cluster topology to
 minimize restarts

Add pytest_collection_modifyitems hook that sorts test modules by their
cluster configuration group. This ensures tests sharing the same CCM
cluster (same name, same node count, same ext opts) run adjacently,
avoiding unnecessary cluster teardown/restart cycles between modules.

Groups: default singledc -> cluster_tests -> shared_aware ->
single_node -> destructive/special clusters.
---
 tests/integration/standard/conftest.py        | 65 ++++++++++++++++++-
 .../standard/test_rate_limit_exceeded.py      |  4 +-
 2 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/tests/integration/standard/conftest.py b/tests/integration/standard/conftest.py
index 6028c2a06d..3adaf371b0 100644
--- a/tests/integration/standard/conftest.py
+++ b/tests/integration/standard/conftest.py
@@ -1,6 +1,69 @@
 import pytest
 import logging
 
+# Cluster topology groups for test ordering.
+# Tests are sorted so that modules sharing the same CCM cluster run
+# together, minimising expensive cluster teardown/restart cycles.
+# Lower number = runs first.  Modules not listed get a high default.
+_MODULE_CLUSTER_ORDER = {
+    # Group 0: default 3-node singledc (CLUSTER_NAME = 'test_cluster')
+    "test_metadata": 0,
+    "test_policies": 0,
+    "test_control_connection": 0,
+    "test_routing": 0,
+    "test_prepared_statements": 0,
+    "test_metrics": 0,
+    "test_connection": 0,
+    "test_concurrent": 0,
+    "test_custom_payload": 0,
+    "test_query_paging": 0,
+    "test_single_interface": 0,
+    "test_rate_limit_exceeded": 0,
+    # Group 1: 'cluster_tests' (--smp 2, 3 nodes)
+    "test_cluster": 1,
+    "test_shard_aware": 1,
+    # Group 2: 'shared_aware' (--smp 2 --memory 2048M, 3 nodes)
+    "test_use_keyspace": 2,
+    "test_client_routes": 2,
+    # Group 3: single-node cluster
+    "test_types": 3,
+    "test_cython_protocol_handlers": 3,
+    "test_custom_protocol_handler": 3,
+    "test_row_factories": 3,
+    "test_udts": 3,
+    "test_client_warnings": 3,
+    "test_application_info": 3,
+    # Group 4: destructive / special clusters (run last)
+    "test_ip_change": 4,
+    "test_authentication": 4,
+    "test_authentication_misconfiguration": 4,
+    "test_custom_cluster": 4,
+    "test_query": 4,
+    # Group 5: tablets (destructive — decommissions a node)
+    "test_tablets": 5,
+    # Group 6: schema change + node kill (destructive — kills node2)
+    "test_concurrent_schema_change_and_node_kill": 6,
+    # Group 7: multi-dc (7 nodes — most expensive to create)
+    "test_rack_aware_policy": 7,
+}
+
+
+def pytest_collection_modifyitems(items):
+    """Sort tests so modules with the same cluster topology are adjacent.
+
+    Uses the original collection index as tie-breaker so that the
+    definition order inside each file is preserved (important for tests
+    that depend on running order, e.g. destructive tablet tests).
+    """
+    orig_order = {id(item): idx for idx, item in enumerate(items)}
+
+    def _sort_key(item):
+        module_name = item.module.__name__.rsplit(".", 1)[-1]
+        return (_MODULE_CLUSTER_ORDER.get(module_name, 99), item.fspath, orig_order[id(item)])
+
+    items[:] = sorted(items, key=_sort_key)
+
+
 # from https://github.com/streamlit/streamlit/pull/5047/files
 def pytest_sessionfinish():
     # We're not waiting for scriptrunner threads to cleanly close before ending the PyTest,
@@ -10,4 +73,4 @@ def pytest_sessionfinish():
     # * https://github.com/pytest-dev/pytest/issues/5282
     # To prevent the exception from being raised on pytest_sessionfinish
     # we disable exception raising in logging module
-    logging.raiseExceptions = False
\ No newline at end of file
+    logging.raiseExceptions = False
diff --git a/tests/integration/standard/test_rate_limit_exceeded.py b/tests/integration/standard/test_rate_limit_exceeded.py
index 211f0c9930..ea7dfc7d61 100644
--- a/tests/integration/standard/test_rate_limit_exceeded.py
+++ b/tests/integration/standard/test_rate_limit_exceeded.py
@@ -4,13 +4,13 @@
 from cassandra.cluster import Cluster
 from cassandra.policies import ConstantReconnectionPolicy, RoundRobinPolicy, TokenAwarePolicy
 
-from tests.integration import PROTOCOL_VERSION, use_cluster
+from tests.integration import PROTOCOL_VERSION, use_singledc
 import pytest
 
 LOGGER = logging.getLogger(__name__)
 
 def setup_module():
-    use_cluster('rate_limit', [3], start=True)
+    use_singledc()
 
 class TestRateLimitExceededException(unittest.TestCase):
     @classmethod

From b038f4fb6957e13894f7a5da5c43f741c99f8097 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 11:25:39 +0300
Subject: [PATCH 07/49] tests: switch 6 test files from 3-node to single-node
 cluster

These test files don't require multiple nodes for their test logic
(they test data types, protocol handlers, row factories, UDTs, and
client warnings). Using a single node reduces resource usage and
cluster startup time.

Files switched from use_singledc() to use_single_node():
- test_types.py
- test_cython_protocol_handlers.py
- test_custom_protocol_handler.py
- test_row_factories.py
- test_udts.py
- test_client_warnings.py
---
 tests/integration/standard/test_client_warnings.py          | 4 ++--
 tests/integration/standard/test_custom_protocol_handler.py  | 4 ++--
 tests/integration/standard/test_cython_protocol_handlers.py | 4 ++--
 tests/integration/standard/test_row_factories.py            | 4 ++--
 tests/integration/standard/test_types.py                    | 4 ++--
 tests/integration/standard/test_udts.py                     | 4 ++--
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/integration/standard/test_client_warnings.py b/tests/integration/standard/test_client_warnings.py
index 781b5b7860..c18fa8cb1f 100644
--- a/tests/integration/standard/test_client_warnings.py
+++ b/tests/integration/standard/test_client_warnings.py
@@ -17,13 +17,13 @@
 
 from cassandra.query import BatchStatement
 
-from tests.integration import (use_singledc, PROTOCOL_VERSION, local, TestCluster,
+from tests.integration import (use_single_node, PROTOCOL_VERSION, local, TestCluster,
                                requires_custom_payload, xfail_scylla)
 from tests.util import assertRegex, assertDictEqual
 
 
 def setup_module():
-    use_singledc()
+    use_single_node()
 
 @xfail_scylla('scylladb/scylladb#10196 - scylla does not report warnings')
 class ClientWarningTests(unittest.TestCase):
diff --git a/tests/integration/standard/test_custom_protocol_handler.py b/tests/integration/standard/test_custom_protocol_handler.py
index 239f7e7336..e123f2050e 100644
--- a/tests/integration/standard/test_custom_protocol_handler.py
+++ b/tests/integration/standard/test_custom_protocol_handler.py
@@ -20,7 +20,7 @@
     ContinuousPagingOptions, NoHostAvailable)
 from cassandra import ProtocolVersion, ConsistencyLevel
 
-from tests.integration import use_singledc, drop_keyspace_shutdown_cluster, \
+from tests.integration import use_single_node, drop_keyspace_shutdown_cluster, \
     greaterthanorequalcass30, execute_with_long_wait_retry, greaterthanorequalcass3_10, \
     TestCluster, greaterthanorequalcass40
 from tests.integration.datatype_utils import update_datatypes, PRIMITIVE_DATATYPES
@@ -32,7 +32,7 @@
 
 
 def setup_module():
-    use_singledc()
+    use_single_node()
     update_datatypes()
 
 
diff --git a/tests/integration/standard/test_cython_protocol_handlers.py b/tests/integration/standard/test_cython_protocol_handlers.py
index f44d613c64..9c94b2ac77 100644
--- a/tests/integration/standard/test_cython_protocol_handlers.py
+++ b/tests/integration/standard/test_cython_protocol_handlers.py
@@ -12,7 +12,7 @@
 from cassandra.protocol import ProtocolHandler, LazyProtocolHandler, NumpyProtocolHandler
 from cassandra.query import tuple_factory
 from tests import VERIFY_CYTHON
-from tests.integration import use_singledc, notprotocolv1, \
+from tests.integration import use_single_node, notprotocolv1, \
     drop_keyspace_shutdown_cluster, BasicSharedKeyspaceUnitTestCase, greaterthancass21, TestCluster
 from tests.integration.datatype_utils import update_datatypes
 from tests.integration.standard.utils import (
@@ -21,7 +21,7 @@
 
 
 def setup_module():
-    use_singledc()
+    use_single_node()
     update_datatypes()
 
 
diff --git a/tests/integration/standard/test_row_factories.py b/tests/integration/standard/test_row_factories.py
index 187f35704a..818f11c061 100644
--- a/tests/integration/standard/test_row_factories.py
+++ b/tests/integration/standard/test_row_factories.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from tests.integration import get_server_versions, use_singledc, \
+from tests.integration import get_server_versions, use_single_node, \
     BasicSharedKeyspaceUnitTestCaseWFunctionTable, BasicSharedKeyspaceUnitTestCase, execute_until_pass, TestCluster
 
 import unittest
@@ -24,7 +24,7 @@
 
 
 def setup_module():
-    use_singledc()
+    use_single_node()
 
 
 class NameTupleFactory(BasicSharedKeyspaceUnitTestCase):
diff --git a/tests/integration/standard/test_types.py b/tests/integration/standard/test_types.py
index 1d66ce1ed9..559a6b3da0 100644
--- a/tests/integration/standard/test_types.py
+++ b/tests/integration/standard/test_types.py
@@ -38,7 +38,7 @@
 from tests.unit.cython.utils import cythontest
 from tests.util import assertEqual
 
-from tests.integration import use_singledc, execute_until_pass, notprotocolv1, \
+from tests.integration import use_single_node, execute_until_pass, notprotocolv1, \
     BasicSharedKeyspaceUnitTestCase, greaterthancass21, lessthancass30, \
     greaterthanorequalcass3_10, TestCluster, requires_composite_type, \
     requires_vector_type
@@ -48,7 +48,7 @@
 
 
 def setup_module():
-    use_singledc()
+    use_single_node()
     update_datatypes()
 
 
diff --git a/tests/integration/standard/test_udts.py b/tests/integration/standard/test_udts.py
index dd696ea0e9..e608a9610b 100644
--- a/tests/integration/standard/test_udts.py
+++ b/tests/integration/standard/test_udts.py
@@ -21,7 +21,7 @@
 from cassandra.query import dict_factory
 from cassandra.util import OrderedMap
 
-from tests.integration import use_singledc, execute_until_pass, \
+from tests.integration import use_single_node, execute_until_pass, \
     BasicSegregatedKeyspaceUnitTestCase, greaterthancass20, lessthancass30, greaterthanorequalcass36, TestCluster
 from tests.integration.datatype_utils import update_datatypes, PRIMITIVE_DATATYPES, PRIMITIVE_DATATYPES_KEYS, \
     COLLECTION_TYPES, get_sample, get_collection_sample
@@ -32,7 +32,7 @@
 
 
 def setup_module():
-    use_singledc()
+    use_single_node()
     update_datatypes()
 
 

From ca0758df60154d729e50305a03a150fe3d02af63 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 11:27:50 +0300
Subject: [PATCH 08/49] tests: reduce cluster churn in LoadBalancingPolicyTests

Move remove_cluster() from setUp (which ran before every test) to only
the destructive test methods that actually need a fresh cluster.

Read-only tests (test_token_aware_is_used_by_default,
test_token_aware_composite_key, test_token_aware_with_local_table,
test_dc_aware_roundrobin_two_dcs, test_dc_aware_roundrobin_two_dcs_2)
can now reuse an existing cluster, avoiding 5 unnecessary cluster
teardown/startup cycles.
---
 .../integration/long/test_loadbalancingpolicies.py  | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/tests/integration/long/test_loadbalancingpolicies.py b/tests/integration/long/test_loadbalancingpolicies.py
index fd8edde14c..072786dc23 100644
--- a/tests/integration/long/test_loadbalancingpolicies.py
+++ b/tests/integration/long/test_loadbalancingpolicies.py
@@ -45,7 +45,6 @@
 class LoadBalancingPolicyTests(unittest.TestCase):
 
     def setUp(self):
-        remove_cluster()  # clear ahead of test so it doesn't use one left in unknown state
         self.coordinator_stats = CoordinatorStats()
         self.prepared = None
         self.probe_cluster = None
@@ -191,6 +190,7 @@ def test_token_aware_is_used_by_default(self):
             assert isinstance(cluster.profile_manager.default.load_balancing_policy, DCAwareRoundRobinPolicy)
 
     def test_roundrobin(self):
+        remove_cluster()
         use_singledc()
         keyspace = 'test_roundrobin'
         cluster, session = self._cluster_session_with_lbp(RoundRobinPolicy())
@@ -228,6 +228,7 @@ def test_roundrobin(self):
         self.coordinator_stats.assert_query_count_equals(3, 6)
 
     def test_roundrobin_two_dcs(self):
+        remove_cluster()
         use_multidc([2, 2])
         keyspace = 'test_roundrobin_two_dcs'
         cluster, session = self._cluster_session_with_lbp(RoundRobinPolicy())
@@ -261,6 +262,7 @@ def test_roundrobin_two_dcs(self):
         self.coordinator_stats.assert_query_count_equals(5, 3)
 
     def test_roundrobin_two_dcs_2(self):
+        remove_cluster()
         use_multidc([2, 2])
         keyspace = 'test_roundrobin_two_dcs_2'
         cluster, session = self._cluster_session_with_lbp(RoundRobinPolicy())
@@ -294,6 +296,7 @@ def test_roundrobin_two_dcs_2(self):
         self.coordinator_stats.assert_query_count_equals(5, 3)
 
     def test_dc_aware_roundrobin_two_dcs(self):
+        remove_cluster()
         use_multidc([3, 2])
         keyspace = 'test_dc_aware_roundrobin_two_dcs'
         cluster, session = self._cluster_session_with_lbp(DCAwareRoundRobinPolicy('dc1'))
@@ -311,6 +314,7 @@ def test_dc_aware_roundrobin_two_dcs(self):
         self.coordinator_stats.assert_query_count_equals(5, 0)
 
     def test_dc_aware_roundrobin_two_dcs_2(self):
+        remove_cluster()
         use_multidc([3, 2])
         keyspace = 'test_dc_aware_roundrobin_two_dcs_2'
         cluster, session = self._cluster_session_with_lbp(DCAwareRoundRobinPolicy('dc2'))
@@ -328,6 +332,7 @@ def test_dc_aware_roundrobin_two_dcs_2(self):
         self.coordinator_stats.assert_query_count_equals(5, 6)
 
     def test_dc_aware_roundrobin_one_remote_host(self):
+        remove_cluster()
         use_multidc([2, 2])
         keyspace = 'test_dc_aware_roundrobin_one_remote_host'
         cluster, session = self._cluster_session_with_lbp(DCAwareRoundRobinPolicy('dc2', used_hosts_per_remote_dc=1))
@@ -410,6 +415,7 @@ def test_token_aware_prepared(self):
         self.token_aware(keyspace, True)
 
     def token_aware(self, keyspace, use_prepared=False):
+        remove_cluster()
         use_singledc()
         cluster, session = self._cluster_session_with_lbp(TokenAwarePolicy(RoundRobinPolicy()))
         self.addCleanup(cluster.shutdown)
@@ -505,6 +511,7 @@ def test_token_aware_composite_key(self):
         assert results[0].i
 
     def test_token_aware_with_rf_2(self, use_prepared=False):
+        remove_cluster()
         use_singledc()
         keyspace = 'test_token_aware_with_rf_2'
         cluster, session = self._cluster_session_with_lbp(TokenAwarePolicy(RoundRobinPolicy()))
@@ -617,6 +624,7 @@ def test_token_aware_with_transient_replication(self):
 
         @test_category policy
         """
+        remove_cluster()
         # We can test this with a single dc when CASSANDRA-15670 is fixed
         use_multidc([3, 3])
 
@@ -647,6 +655,7 @@ def test_token_aware_with_transient_replication(self):
 
 
     def _set_up_shuffle_test(self, keyspace, replication_factor):
+        remove_cluster()
         use_singledc()
         cluster, session = self._cluster_session_with_lbp(
             TokenAwarePolicy(RoundRobinPolicy(), shuffle_replicas=True)
@@ -678,6 +687,7 @@ def _check_query_order_changes(self, session, keyspace):
             self.coordinator_stats.reset_counts()
 
     def test_white_list(self):
+        remove_cluster()
         use_singledc()
         keyspace = 'test_white_list'
 
@@ -723,6 +733,7 @@ def test_black_list_with_host_filter_policy(self):
 
         @test_category policy
         """
+        remove_cluster()
         use_singledc()
         keyspace = 'test_black_list_with_hfp'
         ignored_address = (IP_FORMAT % 2)

From 226bd109439633f86b66c4c0a7e708fbfa537645 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 27 Mar 2026 12:45:54 +0300
Subject: [PATCH 09/49] tests: fix auth warning assertion for --smp 2
 compatibility

The test_can_connect_with_sslauth test asserted exact equality between
auth warning count and ReadyMessage count. With --smp 2, shard-aware
connections produce additional ReadyMessages, breaking the equality.

Drop the exact equality check and assert a lower bound of >= 3 (one
per node connection in a 3-node cluster).  The control connection and
shard-aware connections may produce additional warnings, so the actual
count varies between runs.
---
 tests/integration/standard/test_cluster.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/tests/integration/standard/test_cluster.py b/tests/integration/standard/test_cluster.py
index 6db9657932..3dd08aae07 100644
--- a/tests/integration/standard/test_cluster.py
+++ b/tests/integration/standard/test_cluster.py
@@ -720,10 +720,13 @@ def _warning_are_issued_when_auth(self, auth_provider):
                 session = cluster.connect()
                 assert session.execute("SELECT * from system.local WHERE key='local'") is not None
 
-            # Three conenctions to nodes plus the control connection
+            # Verify that auth warnings are issued for connections where
+            # auth is configured but the server does not send a challenge.
+            # At minimum one warning per node connection (3 for a 3-node
+            # cluster).  The control connection and shard-aware connections
+            # may add more, so we only assert a lower bound.
             auth_warning = mock_handler.get_message_count('warning', "An authentication challenge was not sent")
-            assert auth_warning >= 4
-            assert auth_warning == mock_handler.get_message_count("debug", "Got ReadyMessage on new connection")
+            assert auth_warning >= 3
 
     def _wait_for_all_shard_connections(self, cluster, timeout=30):
         """Wait until all shard-aware connections are fully established."""

From 4eb1bfac72a1a4ecc9f303b3dc348e60584a1139 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Sat, 28 Mar 2026 15:29:40 +0300
Subject: [PATCH 10/49] tests: shorten cluster name to avoid Unix socket path
 limit

The cluster name 'test_concurrent_schema_change_and_node_kill' (43 chars)
causes the maintenance socket path to exceed the 107-byte sun_path
limit on Linux when the working directory is deep enough.  Shorten to
'test_schema_kill' to stay well within the limit for all environments.
---
 .../standard/test_concurrent_schema_change_and_node_kill.py     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py b/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py
index aeda381c0d..910dcaa9fe 100644
--- a/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py
+++ b/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py
@@ -8,7 +8,7 @@
 
 
 def setup_module():
-    use_cluster('test_concurrent_schema_change_and_node_kill', [3], start=True)
+    use_cluster('test_schema_kill', [3], start=True)
 
 @local
 class TestConcurrentSchemaChangeAndNodeKill(unittest.TestCase):

From f3ec8817a33acd9b3d907a181f509b271bd7d7f6 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Sat, 28 Mar 2026 20:35:48 +0300
Subject: [PATCH 11/49] tests: save/restore SCYLLA_EXT_OPTS to prevent env
 variable leak

Several test modules set SCYLLA_EXT_OPTS in setup_module() but never
restore it in teardown_module(). When tests are reordered to share
clusters, stale values can leak into subsequent modules and cause
misconfigured clusters.

Save the original value before overwriting and restore it on
teardown in:
- test_cluster.py
- test_shard_aware.py
- test_use_keyspace.py
- test_ip_change.py
- test_client_routes.py (module-level and TestFullNodeReplacementThroughNlb)
- test_authentication.py
---
 .../integration/standard/test_authentication.py |  8 ++++++++
 .../integration/standard/test_client_routes.py  | 17 +++++++++++++++++
 tests/integration/standard/test_cluster.py      | 12 ++++++++++++
 tests/integration/standard/test_ip_change.py    | 11 +++++++++++
 tests/integration/standard/test_shard_aware.py  | 12 ++++++++++++
 tests/integration/standard/test_use_keyspace.py | 11 +++++++++++
 6 files changed, 71 insertions(+)

diff --git a/tests/integration/standard/test_authentication.py b/tests/integration/standard/test_authentication.py
index 502fdf8993..f172707fff 100644
--- a/tests/integration/standard/test_authentication.py
+++ b/tests/integration/standard/test_authentication.py
@@ -34,8 +34,12 @@
 #This can be tested for remote hosts, but the cluster has to be configured accordingly
 #@local
 
+_saved_scylla_ext_opts = None
+
 
 def setup_module():
+    global _saved_scylla_ext_opts
+    _saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
     if CASSANDRA_IP.startswith("127.0.0.") and not USE_CASS_EXTERNAL:
         use_singledc(start=False)
         ccm_cluster = get_cluster()
@@ -71,6 +75,10 @@ def _check_auth_ready():
 
 def teardown_module():
     remove_cluster()  # this test messes with config
+    if _saved_scylla_ext_opts is None:
+        os.environ.pop('SCYLLA_EXT_OPTS', None)
+    else:
+        os.environ['SCYLLA_EXT_OPTS'] = _saved_scylla_ext_opts
 
 
 class AuthenticationTests(unittest.TestCase):
diff --git a/tests/integration/standard/test_client_routes.py b/tests/integration/standard/test_client_routes.py
index a799073e25..9471c95867 100644
--- a/tests/integration/standard/test_client_routes.py
+++ b/tests/integration/standard/test_client_routes.py
@@ -519,10 +519,22 @@ def assert_routes_direct(test, cluster, expected_node_ids, direct_port=9042):
         )
 
 
+_saved_scylla_ext_opts = None
+
+
 def setup_module():
+    global _saved_scylla_ext_opts
+    _saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2 --memory 2048M"
     use_cluster('shared_aware', [3], start=True)
 
+
+def teardown_module():
+    if _saved_scylla_ext_opts is None:
+        os.environ.pop('SCYLLA_EXT_OPTS', None)
+    else:
+        os.environ['SCYLLA_EXT_OPTS'] = _saved_scylla_ext_opts
+
 @skip_scylla_version_lt(reason='scylladb/scylladb#26992 - system.client_routes is not yet supported',
                         scylla_version="2026.1.0")
 class TestGetHostPortMapping(unittest.TestCase):
@@ -1116,6 +1128,7 @@ class TestFullNodeReplacementThroughNlb(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
+        cls._saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
         os.environ['SCYLLA_EXT_OPTS'] = "--smp 2 --memory 2048M"
         use_cluster('test_client_routes_replacement', [3], start=True)
 
@@ -1133,6 +1146,10 @@ def setUpClass(cls):
     @classmethod
     def tearDownClass(cls):
         cls.direct_cluster.shutdown()
+        if cls._saved_scylla_ext_opts is None:
+            os.environ.pop('SCYLLA_EXT_OPTS', None)
+        else:
+            os.environ['SCYLLA_EXT_OPTS'] = cls._saved_scylla_ext_opts
 
     def test_should_survive_full_node_replacement_through_nlb(self):
         """
diff --git a/tests/integration/standard/test_cluster.py b/tests/integration/standard/test_cluster.py
index 3dd08aae07..08b823d716 100644
--- a/tests/integration/standard/test_cluster.py
+++ b/tests/integration/standard/test_cluster.py
@@ -51,12 +51,24 @@
 log = logging.getLogger(__name__)
 
 
+_saved_scylla_ext_opts = None
+
+
 def setup_module():
+    global _saved_scylla_ext_opts
+    _saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2"
     use_cluster("cluster_tests", [3], start=True, workloads=None)
     warnings.simplefilter("always")
 
 
+def teardown_module():
+    if _saved_scylla_ext_opts is None:
+        os.environ.pop('SCYLLA_EXT_OPTS', None)
+    else:
+        os.environ['SCYLLA_EXT_OPTS'] = _saved_scylla_ext_opts
+
+
 class IgnoredHostPolicy(RoundRobinPolicy):
 
     def __init__(self, ignored_hosts):
diff --git a/tests/integration/standard/test_ip_change.py b/tests/integration/standard/test_ip_change.py
index 6d23d30e04..53debfa1f5 100644
--- a/tests/integration/standard/test_ip_change.py
+++ b/tests/integration/standard/test_ip_change.py
@@ -10,11 +10,22 @@
 
 LOGGER = logging.getLogger(__name__)
 
+_saved_scylla_ext_opts = None
+
 
 def setup_module():
+    global _saved_scylla_ext_opts
+    _saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2 --memory 2048M"
     use_cluster('test_ip_change', [3], start=True)
 
+
+def teardown_module():
+    if _saved_scylla_ext_opts is None:
+        os.environ.pop('SCYLLA_EXT_OPTS', None)
+    else:
+        os.environ['SCYLLA_EXT_OPTS'] = _saved_scylla_ext_opts
+
 @local
 class TestIpAddressChange(unittest.TestCase):
     @classmethod
diff --git a/tests/integration/standard/test_shard_aware.py b/tests/integration/standard/test_shard_aware.py
index 0fdb9ed08d..d1f3e27abd 100644
--- a/tests/integration/standard/test_shard_aware.py
+++ b/tests/integration/standard/test_shard_aware.py
@@ -31,11 +31,23 @@
 LOGGER = logging.getLogger(__name__)
 
 
+_saved_scylla_ext_opts = None
+
+
 def setup_module():
+    global _saved_scylla_ext_opts
+    _saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2"
     use_cluster('cluster_tests', [3], start=True)
 
 
+def teardown_module():
+    if _saved_scylla_ext_opts is None:
+        os.environ.pop('SCYLLA_EXT_OPTS', None)
+    else:
+        os.environ['SCYLLA_EXT_OPTS'] = _saved_scylla_ext_opts
+
+
 class TestShardAwareIntegration(unittest.TestCase):
     @classmethod
     def setup_class(cls):
diff --git a/tests/integration/standard/test_use_keyspace.py b/tests/integration/standard/test_use_keyspace.py
index 25e954b956..80e7cfe5f3 100644
--- a/tests/integration/standard/test_use_keyspace.py
+++ b/tests/integration/standard/test_use_keyspace.py
@@ -14,12 +14,23 @@
 
 LOGGER = logging.getLogger(__name__)
 
+_saved_scylla_ext_opts = None
+
 
 def setup_module():
+    global _saved_scylla_ext_opts
+    _saved_scylla_ext_opts = os.environ.get('SCYLLA_EXT_OPTS')
     os.environ['SCYLLA_EXT_OPTS'] = "--smp 2 --memory 2048M"
     use_cluster('shared_aware', [3], start=True)
 
 
+def teardown_module():
+    if _saved_scylla_ext_opts is None:
+        os.environ.pop('SCYLLA_EXT_OPTS', None)
+    else:
+        os.environ['SCYLLA_EXT_OPTS'] = _saved_scylla_ext_opts
+
+
 @local
 class TestUseKeyspace(unittest.TestCase):
     @classmethod

From 92aa6690724969597cc6a79f70f1a1cb70c550ef Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Sat, 28 Mar 2026 20:37:15 +0300
Subject: [PATCH 12/49] ci: cache Scylla download across CI matrix jobs

Add an actions/cache step for ~/.ccm/repository keyed on the Scylla
version and runner OS. On cache hit the 'Download Scylla' step
becomes a near-instant no-op. On miss (or version bump) CCM
re-downloads as before, so there is no regression risk.
---
 .github/workflows/integration-tests.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 048dbd1352..3c75a33603 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -77,6 +77,12 @@ jobs:
     - name: Build driver
       run: uv sync
 
+    - name: Cache Scylla download
+      uses: actions/cache@v4
+      with:
+        path: ~/.ccm/repository
+        key: scylla-${{ env.SCYLLA_VERSION }}-${{ runner.os }}
+
     # This is to get honest accounting of test time vs download time vs build time.
     # Not strictly necessary for running tests.
     - name: Download Scylla

From 56498e3aafc7c90f9d5b6668c8f2c74c033a42ca Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Sun, 29 Mar 2026 13:34:52 +0300
Subject: [PATCH 13/49] tests: fix flaky SSL test by increasing connect timeout
 and retry budget

The routes_visible() polling function in TestSslThroughNlb creates a new
TestCluster with SSL on every retry attempt.  Under resource pressure
(--smp 2 --memory 2048M shared across 3 nodes), the SSL handshake plus
CQL negotiation can exceed the default 5-second connect_timeout, causing
intermittent OperationTimedOut failures.

Fix by passing connect_timeout=30 to TestCluster (matching the generous
timeout recommended for slow-starting clusters) and increasing the
wait_until_not_raised parameters from (0.5, 10) to (1, 30), consistent
with other wait_until_not_raised calls in this file (lines 773, 855).
---
 tests/integration/standard/test_client_routes.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/integration/standard/test_client_routes.py b/tests/integration/standard/test_client_routes.py
index 9471c95867..5a20421276 100644
--- a/tests/integration/standard/test_client_routes.py
+++ b/tests/integration/standard/test_client_routes.py
@@ -1059,7 +1059,7 @@ def test_ssl_without_hostname_verification_through_nlb(self):
             def routes_visible():
                 with TestCluster(
                     contact_points=["127.0.0.1"],
-                    ssl_context=ssl_ctx,
+                    ssl_context=ssl_ctx, connect_timeout=30,
                 ) as c:
                     session = c.connect()
                     rs = session.execute(
@@ -1071,7 +1071,7 @@ def routes_visible():
 
             wait_until_not_raised(
                 lambda: self.assertTrue(routes_visible()),
-                0.5, 10,
+                1, 30,
             )
 
             with Cluster(

From db317eb3645495232664f99c4a452da67b74903e Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Sun, 29 Mar 2026 16:32:08 +0300
Subject: [PATCH 14/49] tests: register custom 'last' pytest mark to suppress
 warning

The test_tablets.py file uses @pytest.mark.last to ensure the
decommission test runs last. Register this mark in pyproject.toml
to eliminate the PytestUnknownMarkWarning.
---
 pyproject.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 7f60ed0b2a..1335027fcd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -121,6 +121,9 @@ log_level = "DEBUG"
 log_date_format = "%Y-%m-%d %H:%M:%S"
 xfail_strict = true
 addopts = "-rf"
+markers = [
+    "last: mark test to run last within its module group",
+]
 
 [tool.setuptools_scm]
 version_file = "cassandra/_version.py"

From 50941184b1c8e5a3aed2b23fc392a50bc540d63b Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Fri, 20 Mar 2026 21:03:47 +0200
Subject: [PATCH 15/49] perf: use stdlib bisect and attrgetter in tablets.py

- Use bisect.bisect_left from stdlib unconditionally (C implementation);
  drop the bundled pure-Python fallback since we only support Python 3.10+
- Replace per-call lambda closures with module-level operator.attrgetter
  for first_token/last_token extraction
- Add unit tests for get_tablet_for_key

Benchmark results (get_tablet_for_key hit):
  10 tablets:    517 ns -> 365 ns (1.42x)
  100 tablets:   616 ns -> 351 ns (1.75x)
  1000 tablets:  1008 ns -> 529 ns (1.91x)
  10000 tablets: 1339 ns -> 610 ns (2.20x)
---
 cassandra/tablets.py       | 48 +++++++-------------------------------
 tests/unit/test_tablets.py | 38 ++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 39 deletions(-)

diff --git a/cassandra/tablets.py b/cassandra/tablets.py
index dca26ab0df..96e61a50c2 100644
--- a/cassandra/tablets.py
+++ b/cassandra/tablets.py
@@ -1,7 +1,13 @@
+from bisect import bisect_left
+from operator import attrgetter
 from threading import Lock
 from typing import Optional
 from uuid import UUID
 
+# C-accelerated attrgetter avoids per-call lambda allocation overhead
+_get_first_token = attrgetter("first_token")
+_get_last_token = attrgetter("last_token")
+
 
 class Tablet(object):
     """
@@ -57,7 +63,7 @@ def get_tablet_for_key(self, keyspace, table, t):
         if not tablet:
             return None
 
-        id = bisect_left(tablet, t.value, key=lambda tablet: tablet.last_token)
+        id = bisect_left(tablet, t.value, key=_get_last_token)
         if id < len(tablet) and t.value > tablet[id].first_token:
             return tablet[id]
         return None
@@ -94,12 +100,12 @@ def add_tablet(self, keyspace, table, tablet):
             tablets_for_table = self._tablets.setdefault((keyspace, table), [])
 
             # find first overlapping range
-            start = bisect_left(tablets_for_table, tablet.first_token, key=lambda t: t.first_token)
+            start = bisect_left(tablets_for_table, tablet.first_token, key=_get_first_token)
             if start > 0 and tablets_for_table[start - 1].last_token > tablet.first_token:
                 start = start - 1
 
             # find last overlapping range
-            end = bisect_left(tablets_for_table, tablet.last_token, key=lambda t: t.last_token)
+            end = bisect_left(tablets_for_table, tablet.last_token, key=_get_last_token)
             if end < len(tablets_for_table) and tablets_for_table[end].first_token >= tablet.last_token:
                 end = end - 1
 
@@ -108,39 +114,3 @@ def add_tablet(self, keyspace, table, tablet):
 
             tablets_for_table.insert(start, tablet)
 
-
-# bisect.bisect_left implementation from Python 3.11, needed untill support for
-# Python < 3.10 is dropped, it is needed to use `key` to extract last_token from
-# Tablet list - better solution performance-wise than materialize list of last_tokens
-def bisect_left(a, x, lo=0, hi=None, *, key=None):
-    """Return the index where to insert item x in list a, assuming a is sorted.
-
-    The return value i is such that all e in a[:i] have e < x, and all e in
-    a[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will
-    insert just before the leftmost x already there.
-
-    Optional args lo (default 0) and hi (default len(a)) bound the
-    slice of a to be searched.
-    """
-
-    if lo < 0:
-        raise ValueError('lo must be non-negative')
-    if hi is None:
-        hi = len(a)
-    # Note, the comparison uses "<" to match the
-    # __lt__() logic in list.sort() and in heapq.
-    if key is None:
-        while lo < hi:
-            mid = (lo + hi) // 2
-            if a[mid] < x:
-                lo = mid + 1
-            else:
-                hi = mid
-        return
-    while lo < hi:
-        mid = (lo + hi) // 2
-        if key(a[mid]) < x:
-            lo = mid + 1
-        else:
-            hi = mid
-    return lo
diff --git a/tests/unit/test_tablets.py b/tests/unit/test_tablets.py
index 5e640fa4c9..7a40e7de4d 100644
--- a/tests/unit/test_tablets.py
+++ b/tests/unit/test_tablets.py
@@ -86,3 +86,41 @@ def test_add_tablet_intersecting_with_last(self):
 
         self.compare_ranges(tablets_list, [(-8611686018427387905, -7917529027641081857),
                                            (-5011686018427387905, -2987529027641081857)])
+
+
+class GetTabletForKeyTest(unittest.TestCase):
+    """Tests for Tablets.get_tablet_for_key."""
+
+    def test_found(self):
+        t1 = Tablet(0, 100, [("host1", 0)])
+        t2 = Tablet(100, 200, [("host2", 0)])
+        t3 = Tablet(200, 300, [("host3", 0)])
+        tablets = Tablets({("ks", "tb"): [t1, t2, t3]})
+
+        class Token:
+            def __init__(self, v):
+                self.value = v
+
+        result = tablets.get_tablet_for_key("ks", "tb", Token(150))
+        self.assertIs(result, t2)
+
+    def test_not_found_empty(self):
+        tablets = Tablets({})
+
+        class Token:
+            def __init__(self, v):
+                self.value = v
+
+        self.assertIsNone(tablets.get_tablet_for_key("ks", "tb", Token(50)))
+
+    def test_not_found_outside_range(self):
+        t1 = Tablet(100, 200, [("host1", 0)])
+        tablets = Tablets({("ks", "tb"): [t1]})
+
+        class Token:
+            def __init__(self, v):
+                self.value = v
+
+        # Token value 50 is not > first_token (100) of the tablet whose
+        # last_token (200) is >= 50, so no match.
+        self.assertIsNone(tablets.get_tablet_for_key("ks", "tb", Token(50)))

From cc78c22b173c08c4ba7843306a7a77ac934f18fd Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Sun, 12 Apr 2026 22:39:13 -0400
Subject: [PATCH 16/49] Add Jira PR sync workflow

---
 .github/workflows/call_jira_sync.yml | 41 ++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 .github/workflows/call_jira_sync.yml

diff --git a/.github/workflows/call_jira_sync.yml b/.github/workflows/call_jira_sync.yml
new file mode 100644
index 0000000000..385737847b
--- /dev/null
+++ b/.github/workflows/call_jira_sync.yml
@@ -0,0 +1,41 @@
+name: Sync Jira Based on PR Events
+
+on:
+  pull_request_target:
+    types: [opened, edited, ready_for_review, review_requested, labeled, unlabeled, closed]
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  jira-sync-pr-opened:
+    if: github.event.action == 'opened' || github.event.action == 'edited'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_pr_opened.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-sync-in-review:
+    if: github.event.action == 'ready_for_review' || github.event.action == 'review_requested'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_in_review.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-sync-add-label:
+    if: github.event.action == 'labeled'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_add_label.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-sync-remove-label:
+    if: github.event.action == 'unlabeled'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_remove_label.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-sync-pr-closed:
+    if: github.event.action == 'closed'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_pr_closed.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}

From d2e3fef87c3aa58a3e68da0b23e034b264044d64 Mon Sep 17 00:00:00 2001
From: Dani Tweig <dani.tweig@scylladb.com>
Date: Tue, 14 Apr 2026 16:49:52 +0300
Subject: [PATCH 17/49] PM-285: Consolidate Jira sync workflow to single job
 calling main_pr_events_jira_sync

---
 .github/workflows/call_jira_sync.yml | 31 ++++------------------------
 1 file changed, 4 insertions(+), 27 deletions(-)

diff --git a/.github/workflows/call_jira_sync.yml b/.github/workflows/call_jira_sync.yml
index 385737847b..14f517df40 100644
--- a/.github/workflows/call_jira_sync.yml
+++ b/.github/workflows/call_jira_sync.yml
@@ -10,32 +10,9 @@ permissions:
   issues: write
 
 jobs:
-  jira-sync-pr-opened:
-    if: github.event.action == 'opened' || github.event.action == 'edited'
-    uses: scylladb/github-automation/.github/workflows/main_jira_sync_pr_opened.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-
-  jira-sync-in-review:
-    if: github.event.action == 'ready_for_review' || github.event.action == 'review_requested'
-    uses: scylladb/github-automation/.github/workflows/main_jira_sync_in_review.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-
-  jira-sync-add-label:
-    if: github.event.action == 'labeled'
-    uses: scylladb/github-automation/.github/workflows/main_jira_sync_add_label.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-
-  jira-sync-remove-label:
-    if: github.event.action == 'unlabeled'
-    uses: scylladb/github-automation/.github/workflows/main_jira_sync_remove_label.yml@main
-    secrets:
-      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
-
-  jira-sync-pr-closed:
-    if: github.event.action == 'closed'
-    uses: scylladb/github-automation/.github/workflows/main_jira_sync_pr_closed.yml@main
+  jira-sync:
+    uses: scylladb/github-automation/.github/workflows/main_pr_events_jira_sync.yml@main
+    with:
+      caller_action: ${{ github.event.action }}
     secrets:
       caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}

From 006babf87f550afdc5f3e03f4080783d2ed48683 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 15 Apr 2026 08:40:31 +0000
Subject: [PATCH 18/49] chore(deps): update github artifact actions

---
 .github/workflows/build-push.yml         | 2 +-
 .github/workflows/lib-build-and-push.yml | 6 +++---
 .github/workflows/publish-manually.yml   | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build-push.yml b/.github/workflows/build-push.yml
index 15c77f3861..7414daec3a 100644
--- a/.github/workflows/build-push.yml
+++ b/.github/workflows/build-push.yml
@@ -23,7 +23,7 @@ jobs:
     permissions:
       id-token: write
     steps:
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           path: dist
           merge-multiple: true
diff --git a/.github/workflows/lib-build-and-push.yml b/.github/workflows/lib-build-and-push.yml
index 735a4638f4..0b1ce47647 100644
--- a/.github/workflows/lib-build-and-push.yml
+++ b/.github/workflows/lib-build-and-push.yml
@@ -153,7 +153,7 @@ jobs:
         run: |
           GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build-and-push.yml@refs/heads/master" CIBW_BUILD="cp3*" cibuildwheel --archs aarch64 --output-dir wheelhouse
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: wheels-${{ matrix.target }}-${{ matrix.os }}
           path: ./wheelhouse/*.whl
@@ -172,7 +172,7 @@ jobs:
       - name: Build sdist
         run: uv build --sdist
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: source-dist
           path: dist/*.tar.gz
@@ -185,7 +185,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           path: dist
           merge-multiple: true
diff --git a/.github/workflows/publish-manually.yml b/.github/workflows/publish-manually.yml
index 09b9779117..83ed290a2b 100644
--- a/.github/workflows/publish-manually.yml
+++ b/.github/workflows/publish-manually.yml
@@ -56,7 +56,7 @@ jobs:
     permissions:
       id-token: write
     steps:
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           path: dist
           merge-multiple: true

From 293e4a15ed190bcb07e43dfba606e8f1fb1a8936 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Wed, 15 Apr 2026 08:40:27 +0000
Subject: [PATCH 19/49] chore(deps): update actions/cache action to v5

---
 .github/workflows/integration-tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 3c75a33603..89f62963b0 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -78,7 +78,7 @@ jobs:
       run: uv sync
 
     - name: Cache Scylla download
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: ~/.ccm/repository
         key: scylla-${{ env.SCYLLA_VERSION }}-${{ runner.os }}

From ee0bc66078322bd5d4e856a8868ba208cef6b752 Mon Sep 17 00:00:00 2001
From: Mikita Hradovich <mikita.hradovich@scylladb.com>
Date: Wed, 15 Apr 2026 13:12:46 +0200
Subject: [PATCH 20/49] CI: fix id-token permission for Test wheels building
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

build-test.yml triggers on pull_request, which gives it id-token:none
by default. lib-build-and-push.yml's upload_pypi job declares
id-token:write, which exceeds the caller's cap and causes GitHub to
reject the workflow at parse time — even though upload:false prevents
upload_pypi from ever running.

Fix: explicitly grant id-token:write to the test-wheels-build job so
the permission cap satisfies the reusable workflow's requirement.

Fixes #819
---
 .github/workflows/build-test.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/build-test.yml b/.github/workflows/build-test.yml
index 3e1f1067d7..b0d261d9d6 100644
--- a/.github/workflows/build-test.yml
+++ b/.github/workflows/build-test.yml
@@ -19,5 +19,7 @@ jobs:
     name: "Test wheels building"
     if: "!contains(github.event.pull_request.labels.*.name, 'disable-test-build')"
     uses: ./.github/workflows/lib-build-and-push.yml
+    permissions:
+      id-token: write
     with:
       upload: false
\ No newline at end of file

From 284bd90f5db6844768fa88bcba07896b20fa96dc Mon Sep 17 00:00:00 2001
From: David Garcia <david@techdocs.studio>
Date: Thu, 12 Mar 2026 12:34:52 +0000
Subject: [PATCH 21/49] docs: update theme 1.9

---
 .github/dependabot.yml        |  2 +-
 .github/workflows/docs-pr.yml |  3 ++
 docs/.gitignore               |  2 +
 docs/conf.py                  |  2 +-
 docs/pyproject.toml           |  8 ++--
 docs/uv.lock                  | 89 +++++++++++++----------------------
 6 files changed, 44 insertions(+), 62 deletions(-)
 create mode 100644 docs/.gitignore

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 28784749c4..ac3943ef57 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,6 +1,6 @@
 version: 2
 updates:
-  - package-ecosystem: "pip"
+  - package-ecosystem: "uv"
     directory: "/docs"
     schedule:
       interval: "daily"
diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index b5651c8159..4158c2912e 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -2,6 +2,9 @@ name: "Docs / Build PR"
 # For more information,
 # see https://sphinx-theme.scylladb.com/stable/deployment/production.html#available-workflows
 
+permissions:
+  contents: read
+
 on:
   push:
     branches:
diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 0000000000..733bc65597
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1,2 @@
+# Track uv.lock for reproducible docs builds
+!uv.lock
diff --git a/docs/conf.py b/docs/conf.py
index 4b6b329525..87a38c6add 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -52,7 +52,7 @@
     'sphinx_sitemap',
     'sphinx_scylladb_theme',
     'sphinx_multiversion',  # optional
-    'recommonmark',  # optional
+    'myst_parser',  # optional
 ]
 
 # Add any paths that contain templates here, relative to this directory.
diff --git a/docs/pyproject.toml b/docs/pyproject.toml
index 59c425229a..762a4f2e49 100644
--- a/docs/pyproject.toml
+++ b/docs/pyproject.toml
@@ -11,13 +11,13 @@ dependencies = [
   "gevent>=25.9.1,<26.0.0",
   "gremlinpython==3.7.4",
   "pygments>=2.19.2,<3.0.0",
-  "recommonmark==0.7.1",
+  "myst-parser>=5.0.0",
   "redirects_cli~=0.1.3",
   "sphinx-autobuild>=2025.0.0,<2026.0.0",
   "sphinx-sitemap>=2.8.0,<3.0.0",
-  "sphinx-scylladb-theme>=1.8.2,<2.0.0",
+  "sphinx-scylladb-theme>=1.9.1",
   "sphinx-multiversion-scylla>=0.3.2,<1.0.0",
-  "sphinx>=8.2.3,<9.0.0",
+  "sphinx>=9.0",
   "six>=1.9",
   "tornado>=6.5,<7.0",
 ]
@@ -57,4 +57,4 @@ exclude = [
   "**/__pycache__/**",
   "**/*.pyc",
   ".venv/**",
-]
\ No newline at end of file
+]
diff --git a/docs/uv.lock b/docs/uv.lock
index 720a2080e7..56b0841403 100644
--- a/docs/uv.lock
+++ b/docs/uv.lock
@@ -205,15 +205,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
-[[package]]
-name = "commonmark"
-version = "0.9.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/60/48/a60f593447e8f0894ebb7f6e6c1f25dafc5e89c5879fdc9360ae93ff83f0/commonmark-0.9.1.tar.gz", hash = "sha256:452f9dc859be7f06631ddcb328b6919c67984aca654e5fefb3914d54691aed60", size = 95764, upload-time = "2019-10-04T15:37:39.817Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/92/dfd892312d822f36c55366118b95d914e5f16de11044a27cf10a7d71bbbf/commonmark-0.9.1-py2.py3-none-any.whl", hash = "sha256:da2f38c92590f83de410ba1a3cbceafbc74fee9def35f9251ba9a971d6d66fd9", size = 51068, upload-time = "2019-10-04T15:37:37.674Z" },
-]
-
 [[package]]
 name = "dnspython"
 version = "2.8.0"
@@ -405,14 +396,14 @@ wheels = [
 
 [[package]]
 name = "markdown-it-py"
-version = "3.0.0"
+version = "4.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mdurl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
+    { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },
 ]
 
 [[package]]
@@ -513,7 +504,7 @@ wheels = [
 
 [[package]]
 name = "myst-parser"
-version = "4.0.1"
+version = "5.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docutils" },
@@ -523,9 +514,9 @@ dependencies = [
     { name = "pyyaml" },
     { name = "sphinx" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985, upload-time = "2025-02-12T10:53:03.833Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/fa/7b45eef11b7971f0beb29d27b7bfe0d747d063aa29e170d9edd004733c8a/myst_parser-5.0.0.tar.gz", hash = "sha256:f6f231452c56e8baa662cc352c548158f6a16fcbd6e3800fc594978002b94f3a", size = 98535, upload-time = "2026-01-15T09:08:18.036Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579, upload-time = "2025-02-12T10:53:02.078Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ac/686789b9145413f1a61878c407210e41bfdb097976864e0913078b24098c/myst_parser-5.0.0-py3-none-any.whl", hash = "sha256:ab31e516024918296e169139072b81592336f2fef55b8986aa31c9f04b5f7211", size = 84533, upload-time = "2026-01-15T09:08:16.788Z" },
 ]
 
 [[package]]
@@ -548,11 +539,11 @@ wheels = [
 
 [[package]]
 name = "pathspec"
-version = "0.12.1"
+version = "1.0.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/36/e27608899f9b8d4dff0617b2d9ab17ca5608956ca44461ac14ac48b44015/pathspec-1.0.4.tar.gz", hash = "sha256:0210e2ae8a21a9137c0d470578cb0e595af87edaa6ebf12ff176f14a02e0e645", size = 131200, upload-time = "2026-01-27T03:59:46.938Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/3c/2c197d226f9ea224a9ab8d197933f9da0ae0aac5b6e0f884e2b8d9c8e9f7/pathspec-1.0.4-py3-none-any.whl", hash = "sha256:fb6ae2fd4e7c921a165808a552060e722767cfa526f99ca5156ed2ce45a5c723", size = 55206, upload-time = "2026-01-27T03:59:45.137Z" },
 ]
 
 [[package]]
@@ -629,8 +620,8 @@ dependencies = [
     { name = "eventlet" },
     { name = "gevent" },
     { name = "gremlinpython" },
+    { name = "myst-parser" },
     { name = "pygments" },
-    { name = "recommonmark" },
     { name = "redirects-cli" },
     { name = "six" },
     { name = "sphinx" },
@@ -651,14 +642,14 @@ requires-dist = [
     { name = "eventlet", specifier = ">=0.40.3,<1.0.0" },
     { name = "gevent", specifier = ">=25.9.1,<26.0.0" },
     { name = "gremlinpython", specifier = "==3.7.4" },
+    { name = "myst-parser", specifier = ">=5.0.0" },
     { name = "pygments", specifier = ">=2.19.2,<3.0.0" },
-    { name = "recommonmark", specifier = "==0.7.1" },
     { name = "redirects-cli", specifier = "~=0.1.3" },
     { name = "six", specifier = ">=1.9" },
-    { name = "sphinx", specifier = ">=8.2.3,<9.0.0" },
+    { name = "sphinx", specifier = ">=9.0" },
     { name = "sphinx-autobuild", specifier = ">=2025.0.0,<2026.0.0" },
     { name = "sphinx-multiversion-scylla", specifier = ">=0.3.2,<1.0.0" },
-    { name = "sphinx-scylladb-theme", specifier = ">=1.8.2,<2.0.0" },
+    { name = "sphinx-scylladb-theme", specifier = ">=1.9.1" },
     { name = "sphinx-sitemap", specifier = ">=2.8.0,<3.0.0" },
     { name = "tornado", specifier = ">=6.5,<7.0" },
 ]
@@ -684,20 +675,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
 ]
 
-[[package]]
-name = "recommonmark"
-version = "0.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "commonmark" },
-    { name = "docutils" },
-    { name = "sphinx" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/1c/00/3dd2bdc4184b0ce754b5b446325abf45c2e0a347e022292ddc44670f628c/recommonmark-0.7.1.tar.gz", hash = "sha256:bdb4db649f2222dcd8d2d844f0006b958d627f732415d399791ee436a3686d67", size = 34444, upload-time = "2020-12-17T19:24:56.523Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/77/ed589c75db5d02a77a1d5d2d9abc63f29676467d396c64277f98b50b79c2/recommonmark-0.7.1-py2.py3-none-any.whl", hash = "sha256:1b1db69af0231efce3fa21b94ff627ea33dee7079a01dd0a7f8482c3da148b3f", size = 10214, upload-time = "2020-12-17T19:24:55.137Z" },
-]
-
 [[package]]
 name = "redirects-cli"
 version = "0.1.3"
@@ -740,12 +717,12 @@ wheels = [
 ]
 
 [[package]]
-name = "roman-numerals-py"
-version = "3.1.0"
+name = "roman-numerals"
+version = "4.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/30/76/48fd56d17c5bdbdf65609abbc67288728a98ed4c02919428d4f52d23b24b/roman_numerals_py-3.1.0.tar.gz", hash = "sha256:be4bf804f083a4ce001b5eb7e3c0862479d10f94c936f6c4e5f250aa5ff5bd2d", size = 9017, upload-time = "2025-02-22T07:34:54.333Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/97/d2cbbaa10c9b826af0e10fdf836e1bf344d9f0abb873ebc34d1f49642d3f/roman_numerals_py-3.1.0-py3-none-any.whl", hash = "sha256:9da2ad2fb670bcf24e81070ceb3be72f6c11c440d73bd579fbeca1e9f330954c", size = 7742, upload-time = "2025-02-22T07:34:52.422Z" },
+    { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" },
 ]
 
 [[package]]
@@ -795,7 +772,7 @@ wheels = [
 
 [[package]]
 name = "sphinx"
-version = "8.2.3"
+version = "9.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "alabaster" },
@@ -807,7 +784,7 @@ dependencies = [
     { name = "packaging" },
     { name = "pygments" },
     { name = "requests" },
-    { name = "roman-numerals-py" },
+    { name = "roman-numerals" },
     { name = "snowballstemmer" },
     { name = "sphinxcontrib-applehelp" },
     { name = "sphinxcontrib-devhelp" },
@@ -816,9 +793,9 @@ dependencies = [
     { name = "sphinxcontrib-qthelp" },
     { name = "sphinxcontrib-serializinghtml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876, upload-time = "2025-03-02T22:31:59.658Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/bd/f08eb0f4eed5c83f1ba2a3bd18f7745a2b1525fad70660a1c00224ec468a/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb", size = 8718324, upload-time = "2025-12-31T15:09:27.646Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741, upload-time = "2025-03-02T22:31:56.836Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f7/b1884cb3188ab181fc81fa00c266699dab600f927a964df02ec3d5d1916a/sphinx-9.1.0-py3-none-any.whl", hash = "sha256:c84fdd4e782504495fe4f2c0b3413d6c2bf388589bb352d439b2a3bb99991978", size = 3921742, upload-time = "2025-12-31T15:09:25.561Z" },
 ]
 
 [[package]]
@@ -840,14 +817,14 @@ wheels = [
 
 [[package]]
 name = "sphinx-collapse"
-version = "0.1.3"
+version = "0.1.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "sphinx" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/02/183559e508906f7282d4dd6ccbf443efddaa3114b7f6fab425949b37a003/sphinx_collapse-0.1.3.tar.gz", hash = "sha256:cae141e6f03ecd52ed246a305a69e1b0d5d05e6cdf3fe803d40d583ad6ad895a", size = 18540, upload-time = "2024-02-22T15:24:38.735Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/14/a1/cb5bb03a5081bd1229b3296c2af347b4147017fdb62777d2aad855cd349f/sphinx_collapse-0.1.4.tar.gz", hash = "sha256:ba860e50839c026cd1abcc164e1e7cb18bcc11c8214150e34a6550461be3229f", size = 19412, upload-time = "2026-02-27T17:47:24.191Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2f/2f/5889082a6a535aa8613a327308582914517082967583ad45586b7d61c145/sphinx_collapse-0.1.3-py3-none-any.whl", hash = "sha256:85fadb2ec8769b93fd04276538668fa96239ef60c20c4a9eaa3e480387a6e65b", size = 4688, upload-time = "2024-02-22T15:24:29.365Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/18/277f4663c97073606917becab629938237f1e03952f4e339f8b7d1f3096b/sphinx_collapse-0.1.4-py3-none-any.whl", hash = "sha256:76e9fa531bafb4984d6ef5f3dbe311982837f5965b7a35eda013bbd9dd41445e", size = 4811, upload-time = "2026-02-27T17:47:22.622Z" },
 ]
 
 [[package]]
@@ -876,14 +853,14 @@ wheels = [
 
 [[package]]
 name = "sphinx-multiversion-scylla"
-version = "0.3.4"
+version = "0.3.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "sphinx" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/48/1d/e2b1a214b20d33cc631422e483ed1c8cf6883870940b58cc46341b65e2d7/sphinx_multiversion_scylla-0.3.4.tar.gz", hash = "sha256:8f7c94a89c794334d78ef21761a8bf455aaa7361e71037cf2ac2ca51cb47a0ba", size = 12427, upload-time = "2025-11-24T07:42:01.506Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/55/b1/83fb37f6c9038469b3bd01453875bb2127b3c03f9f41247394ad2063645c/sphinx_multiversion_scylla-0.3.7.tar.gz", hash = "sha256:fc1ddd58e82cfd8810c1be6db8717a244043c04c1c632e9bd1436415d1db0d3b", size = 12665, upload-time = "2026-02-27T18:43:17.849Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fa/aa/82c27991640fe47921f74894a192d374dc1eb609d2276de4abeefe85f4aa/sphinx_multiversion_scylla-0.3.4-py3-none-any.whl", hash = "sha256:e64d49d39a8eccf06a9cb8bbe88eecb3eb2082e6b91a478b55dc7d0268d8e0b6", size = 12302, upload-time = "2025-11-24T07:42:00.403Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/94/f5b6219ca1136dc0305aaf3fb6c96aa2dfe65224d6dc147e00a6485a1a22/sphinx_multiversion_scylla-0.3.7-py3-none-any.whl", hash = "sha256:6205d261a77c90b7ea3105311d1d56014736a5148966133c34344512bb8c4e4f", size = 12558, upload-time = "2026-02-27T18:43:16.988Z" },
 ]
 
 [[package]]
@@ -900,7 +877,7 @@ wheels = [
 
 [[package]]
 name = "sphinx-scylladb-theme"
-version = "1.8.10"
+version = "1.9.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -913,9 +890,9 @@ dependencies = [
     { name = "sphinx-tabs" },
     { name = "sphinxcontrib-mermaid" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/18/cd/bbd41f0d058f0ef4997cb044326f15dd28a1a17a4336e9b52cb67b8dd242/sphinx_scylladb_theme-1.8.10.tar.gz", hash = "sha256:8a78a9b692d9a946be2c4a64aa472fd82204cc8ea0b1ee7f60de6db35b356326", size = 1620675, upload-time = "2025-12-05T16:49:38.942Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4e/e49e351d4c429b8fe3090657d39e956d53dff61187d783caac1cba81bd72/sphinx_scylladb_theme-1.9.1.tar.gz", hash = "sha256:2ba6367f005d2c68eee1916cc16385989b8e53bbddcc81193003bdeb3bd3415e", size = 1676201, upload-time = "2026-03-09T18:10:43.841Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4c/0e/7577d9bb6e2e7378e6c9f49263c59061a2ae9e370b806d8d1fd8c3be2a23/sphinx_scylladb_theme-1.8.10-py3-none-any.whl", hash = "sha256:8b930f33bec7308ccaa92698ebb5ad85059bcbf93a463f92917aeaf473fce632", size = 1662434, upload-time = "2025-12-05T16:49:36.265Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/30/2b2bae1b022d1fabef405a4857f160464548e08d924f24d0b26d0ca6a848/sphinx_scylladb_theme-1.9.1-py3-none-any.whl", hash = "sha256:6156d60befc3da03bd11991fec9bc590e27ce7cc4ab05aa334edd5611424b106", size = 1662204, upload-time = "2026-03-09T18:10:45.638Z" },
 ]
 
 [[package]]
@@ -1057,11 +1034,11 @@ wheels = [
 
 [[package]]
 name = "trove-classifiers"
-version = "2025.12.1.14"
+version = "2026.1.14.14"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/80/e1/000add3b3e0725ce7ee0ea6ea4543f1e1d9519742f3b2320de41eeefa7c7/trove_classifiers-2025.12.1.14.tar.gz", hash = "sha256:a74f0400524fc83620a9be74a07074b5cbe7594fd4d97fd4c2bfde625fdc1633", size = 16985, upload-time = "2025-12-01T14:47:11.456Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/43/7935f8ea93fcb6680bc10a6fdbf534075c198eeead59150dd5ed68449642/trove_classifiers-2026.1.14.14.tar.gz", hash = "sha256:00492545a1402b09d4858605ba190ea33243d361e2b01c9c296ce06b5c3325f3", size = 16997, upload-time = "2026-01-14T14:54:50.526Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/7e/bc19996fa86cad8801e8ffe6f1bba5836ca0160df76d0410d27432193712/trove_classifiers-2025.12.1.14-py3-none-any.whl", hash = "sha256:a8206978ede95937b9959c3aff3eb258bbf7b07dff391ddd4ea7e61f316635ab", size = 14184, upload-time = "2025-12-01T14:47:10.113Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/4a/2e5583e544bc437d5e8e54b47db87430df9031b29b48d17f26d129fa60c0/trove_classifiers-2026.1.14.14-py3-none-any.whl", hash = "sha256:1f9553927f18d0513d8e5ff80ab8980b8202ce37ecae0e3274ed2ef11880e74d", size = 14197, upload-time = "2026-01-14T14:54:49.067Z" },
 ]
 
 [[package]]

From ca5b8c244de0c162dcb002728c53ac10fe4537a7 Mon Sep 17 00:00:00 2001
From: Mikita Hradovich <mikita.hradovich@scylladb.com>
Date: Thu, 16 Apr 2026 21:25:48 +0200
Subject: [PATCH 22/49] pool: fix inverted cooldown check in
 _get_shard_aware_endpoint

The `block_until < time.time()` condition was true only *after* the
NAT-detection cooldown had already expired, so the shard-aware port
was never suppressed during the 10-minute window and was permanently
disabled once that window closed.  Fix: flip to `>` so the guard
fires while the deadline is in the future.

Add unit test covering the active-block, expired-block, and
hard-disable paths to prevent regression.
---
 cassandra/pool.py              |   2 +-
 tests/unit/test_shard_aware.py | 138 +++++++++++++++++++++------------
 2 files changed, 90 insertions(+), 50 deletions(-)

diff --git a/cassandra/pool.py b/cassandra/pool.py
index 227e1b5315..9e949c342c 100644
--- a/cassandra/pool.py
+++ b/cassandra/pool.py
@@ -677,7 +677,7 @@ def disable_advanced_shard_aware(self, secs):
         self.advanced_shardaware_block_until = max(time.time() + secs, self.advanced_shardaware_block_until)
 
     def _get_shard_aware_endpoint(self):
-        if (self.advanced_shardaware_block_until and self.advanced_shardaware_block_until < time.time()) or \
+        if (self.advanced_shardaware_block_until and self.advanced_shardaware_block_until > time.time()) or \
            self._session.cluster.shard_aware_options.disable_shardaware_port:
             return None
 
diff --git a/tests/unit/test_shard_aware.py b/tests/unit/test_shard_aware.py
index e7d26ae207..4b4c2c138d 100644
--- a/tests/unit/test_shard_aware.py
+++ b/tests/unit/test_shard_aware.py
@@ -15,6 +15,7 @@
 import unittest
 
 import logging
+import time
 from unittest.mock import MagicMock
 from concurrent.futures import ThreadPoolExecutor
 
@@ -27,6 +28,45 @@
 LOGGER = logging.getLogger(__name__)
 
 
+class MockSession(MagicMock):
+    is_shutdown = False
+    keyspace = "ks1"
+
+    def __init__(self, is_ssl=False, *args, **kwargs):
+        super(MockSession, self).__init__(*args, **kwargs)
+        self.cluster = MagicMock()
+        if is_ssl:
+            self.cluster.ssl_options = {'some_ssl_options': True}
+        else:
+            self.cluster.ssl_options = None
+        self.cluster.shard_aware_options = ShardAwareOptions()
+        self.cluster.executor = ThreadPoolExecutor(max_workers=2)
+        self.cluster.signal_connection_failure = lambda *args, **kwargs: False
+        self.cluster.connection_factory = self.mock_connection_factory
+        self.connection_counter = 0
+        self.futures = []
+
+    def submit(self, fn, *args, **kwargs):
+        logging.info("Scheduling %s with args: %s, kwargs: %s", fn, args, kwargs)
+        if not self.is_shutdown:
+            f = self.cluster.executor.submit(fn, *args, **kwargs)
+            self.futures += [f]
+            return f
+
+    def mock_connection_factory(self, *args, **kwargs):
+        connection = MagicMock()
+        connection.is_shutdown = False
+        connection.is_defunct = False
+        connection.is_closed = False
+        connection.orphaned_threshold_reached = False
+        connection.endpoint = args[0]
+        sharding_info = ShardingInfo(shard_id=1, shards_count=4, partitioner="", sharding_algorithm="", sharding_ignore_msb=0, shard_aware_port=19042, shard_aware_port_ssl=19045)
+        connection.features = ProtocolFeatures(shard_id=kwargs.get('shard_id', self.connection_counter), sharding_info=sharding_info)
+        self.connection_counter += 1
+
+        return connection
+
+
 class TestShardAware(unittest.TestCase):
     def test_parsing_and_calculating_shard_id(self):
         """
@@ -55,58 +95,58 @@ def test_advanced_shard_aware_port(self):
         Test that on given a `shard_aware_port` on the OPTIONS message (ShardInfo class)
         the next connections would be open using this port
         """
-        class MockSession(MagicMock):
-            is_shutdown = False
-            keyspace = "ks1"
-
-            def __init__(self, is_ssl=False, *args, **kwargs):
-                super(MockSession, self).__init__(*args, **kwargs)
-                self.cluster = MagicMock()
-                if is_ssl:
-                    self.cluster.ssl_options = {'some_ssl_options': True}
-                else:
-                    self.cluster.ssl_options = None
-                self.cluster.shard_aware_options = ShardAwareOptions()
-                self.cluster.executor = ThreadPoolExecutor(max_workers=2)
-                self.cluster.signal_connection_failure = lambda *args, **kwargs: False
-                self.cluster.connection_factory = self.mock_connection_factory
-                self.connection_counter = 0
-                self.futures = []
-
-            def submit(self, fn, *args, **kwargs):
-                logging.info("Scheduling %s with args: %s, kwargs: %s", fn, args, kwargs)
-                if not self.is_shutdown:
-                    f = self.cluster.executor.submit(fn, *args, **kwargs)
-                    self.futures += [f]
-                    return f
-
-            def mock_connection_factory(self, *args, **kwargs):
-                connection = MagicMock()
-                connection.is_shutdown = False
-                connection.is_defunct = False
-                connection.is_closed = False
-                connection.orphaned_threshold_reached = False
-                connection.endpoint = args[0] 
-                sharding_info = ShardingInfo(shard_id=1, shards_count=4, partitioner="", sharding_algorithm="", sharding_ignore_msb=0, shard_aware_port=19042, shard_aware_port_ssl=19045)
-                connection.features = ProtocolFeatures(shard_id=kwargs.get('shard_id', self.connection_counter), sharding_info=sharding_info)
-                self.connection_counter += 1
-
-                return connection
-
         host = MagicMock()
         host.endpoint = DefaultEndPoint("1.2.3.4")
 
         for port, is_ssl in [(19042, False), (19045, True)]:
             session = MockSession(is_ssl=is_ssl)
             pool = HostConnection(host=host, host_distance=HostDistance.REMOTE, session=session)
-            for f in session.futures:
-                f.result()
-            assert len(pool._connections) == 4
-            for shard_id, connection in pool._connections.items():
-                assert connection.features.shard_id == shard_id
-                if shard_id == 0:
-                    assert connection.endpoint == DefaultEndPoint("1.2.3.4")
-                else:
-                    assert connection.endpoint == DefaultEndPoint("1.2.3.4", port=port)
-
-        session.cluster.executor.shutdown(wait=True)
+            try:
+                for f in session.futures:
+                    f.result()
+                assert len(pool._connections) == 4
+                for shard_id, connection in pool._connections.items():
+                    assert connection.features.shard_id == shard_id
+                    if shard_id == 0:
+                        assert connection.endpoint == DefaultEndPoint("1.2.3.4")
+                    else:
+                        assert connection.endpoint == DefaultEndPoint("1.2.3.4", port=port)
+            finally:
+                session.cluster.executor.shutdown(wait=True)
+
+    def test_advanced_shard_aware_cooldown(self):
+        """
+        `disable_advanced_shard_aware` must suppress the shard-aware endpoint for
+        the duration of the cool-down window, then automatically restore it once
+        the deadline has passed. The hard-disable flag must suppress the endpoint
+        unconditionally.
+        """
+        host = MagicMock()
+        host.endpoint = DefaultEndPoint("1.2.3.4")
+        session = MockSession(is_ssl=False)
+
+        pool = HostConnection(host=host, host_distance=HostDistance.REMOTE, session=session)
+        for f in session.futures:
+            f.result()
+
+        try:
+            # Baseline: shard-aware port is returned.
+            endpoint = pool._get_shard_aware_endpoint()
+            assert endpoint is not None
+            assert endpoint.port == 19042
+
+            # During the cool-down window `_get_shard_aware_endpoint` must return None.
+            pool.disable_advanced_shard_aware(600)
+            assert pool._get_shard_aware_endpoint() is None
+
+            # Once the deadline has passed, the shard-aware port must be used again.
+            pool.advanced_shardaware_block_until = time.time() - 1
+            endpoint = pool._get_shard_aware_endpoint()
+            assert endpoint is not None
+            assert endpoint.port == 19042
+
+            # The hard-disable flag must suppress the endpoint regardless of the timer.
+            session.cluster.shard_aware_options.disable_shardaware_port = True
+            assert pool._get_shard_aware_endpoint() is None
+        finally:
+            session.cluster.executor.shutdown(wait=True)

From 11b427544fc26ba54b03dbd83291abb95235066a Mon Sep 17 00:00:00 2001
From: Mikita Hradovich <mikita.hradovich@scylladb.com>
Date: Fri, 17 Apr 2026 11:03:16 +0200
Subject: [PATCH 23/49] CI: remove dead upload_pypi job from reusable workflow,
 rename to lib-build.yml
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #824. Follow-up to #820.

The upload_pypi job in lib-build-and-push.yml was never reachable: none of the
four caller workflows pass upload: true. build-push.yml and publish-manually.yml
already publish from their own separate jobs (necessary due to how PyPI Trusted
Publishing embeds the caller workflow path in the OIDC token).

Because the reusable workflow declared 'permissions: id-token: write' for
upload_pypi, GitHub's static permission validation forced build-test.yml (a
pull_request workflow, which defaults to id-token: none) to also declare
id-token: write — granting unnecessary privileges to a job that only builds
wheels.

Changes:
- Rename lib-build-and-push.yml -> lib-build.yml (it only builds now)
- Remove upload input and upload_pypi job from the reusable workflow
- Remove 'permissions: id-token: write' and 'with: upload: false' from
  build-test.yml (no longer needed)
- Update all callers (build-push.yml, publish-manually.yml, build-pre-release.yml)
  to reference the new workflow path and drop upload: false from with: blocks
- Replace TODO comments in build-push.yml and publish-manually.yml with an
  explanatory comment: the separate publish job is now intentional design,
  not a temporary workaround
---
 .github/workflows/build-pre-release.yml       |  2 +-
 .github/workflows/build-push.yml              |  9 +++---
 .github/workflows/build-test.yml              |  6 +---
 .../{lib-build-and-push.yml => lib-build.yml} | 29 ++-----------------
 .github/workflows/publish-manually.yml        |  8 +++--
 5 files changed, 15 insertions(+), 39 deletions(-)
 rename .github/workflows/{lib-build-and-push.yml => lib-build.yml} (88%)

diff --git a/.github/workflows/build-pre-release.yml b/.github/workflows/build-pre-release.yml
index e1326b6aa5..f6473c1cc3 100644
--- a/.github/workflows/build-pre-release.yml
+++ b/.github/workflows/build-pre-release.yml
@@ -15,7 +15,7 @@ on:
 
 jobs:
   build-and-publish:
-    uses: ./.github/workflows/lib-build-and-push.yml
+    uses: ./.github/workflows/lib-build.yml
     with:
       python-version: ${{ inputs.python-version }}
       target: ${{ inputs.target }}
diff --git a/.github/workflows/build-push.yml b/.github/workflows/build-push.yml
index 7414daec3a..3a3d93171a 100644
--- a/.github/workflows/build-push.yml
+++ b/.github/workflows/build-push.yml
@@ -10,11 +10,12 @@ on:
 jobs:
   build-and-publish:
     name: "Build wheels"
-    uses: ./.github/workflows/lib-build-and-push.yml
-    with:
-      upload: false
+    uses: ./.github/workflows/lib-build.yml
 
-  # TODO: Remove when https://github.com/pypa/gh-action-pypi-publish/issues/166 is fixed and update build-and-publish.with.upload to ${{ endsWith(github.event.ref, 'scylla') }}
+  # Publishing is a separate job (not inside the reusable workflow) because PyPI Trusted Publishing
+  # requires the *caller* workflow path in the OIDC token. A reusable workflow would embed its own
+  # path instead, causing an `invalid-publisher` error on the PyPI side.
+  # See: https://github.com/pypa/gh-action-pypi-publish/issues/166
   publish:
     name: "Publish wheels to PyPi"
     if: ${{ endsWith(github.event.ref, 'scylla') }}
diff --git a/.github/workflows/build-test.yml b/.github/workflows/build-test.yml
index b0d261d9d6..ebfe383047 100644
--- a/.github/workflows/build-test.yml
+++ b/.github/workflows/build-test.yml
@@ -18,8 +18,4 @@ jobs:
   test-wheels-build:
     name: "Test wheels building"
     if: "!contains(github.event.pull_request.labels.*.name, 'disable-test-build')"
-    uses: ./.github/workflows/lib-build-and-push.yml
-    permissions:
-      id-token: write
-    with:
-      upload: false
\ No newline at end of file
+    uses: ./.github/workflows/lib-build.yml
\ No newline at end of file
diff --git a/.github/workflows/lib-build-and-push.yml b/.github/workflows/lib-build.yml
similarity index 88%
rename from .github/workflows/lib-build-and-push.yml
rename to .github/workflows/lib-build.yml
index 0b1ce47647..f8d0d7a4cc 100644
--- a/.github/workflows/lib-build-and-push.yml
+++ b/.github/workflows/lib-build.yml
@@ -1,14 +1,8 @@
-name: Build and upload to PyPi
+name: Build wheels
 
 on:
   workflow_call:
     inputs:
-      upload:
-        description: 'Upload to PyPI'
-        type: boolean
-        required: false
-        default: false
-
       python-version:
         description: 'Python version to run on'
         type: string
@@ -146,12 +140,12 @@ jobs:
         if: matrix.target != 'linux-aarch64'
         shell: bash
         run: |
-          GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build-and-push.yml@refs/heads/master" cibuildwheel --output-dir wheelhouse
+          GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build.yml@refs/heads/master" cibuildwheel --output-dir wheelhouse
 
       - name: Build wheels for linux aarch64
         if: matrix.target == 'linux-aarch64'
         run: |
-          GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build-and-push.yml@refs/heads/master" CIBW_BUILD="cp3*" cibuildwheel --archs aarch64 --output-dir wheelhouse
+          GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build.yml@refs/heads/master" CIBW_BUILD="cp3*" cibuildwheel --archs aarch64 --output-dir wheelhouse
 
       - uses: actions/upload-artifact@v7
         with:
@@ -176,20 +170,3 @@ jobs:
         with:
           name: source-dist
           path: dist/*.tar.gz
-
-  upload_pypi:
-    if: inputs.upload
-    needs: [build-wheels, build-sdist]
-    runs-on: ubuntu-24.04
-    permissions:
-      id-token: write
-
-    steps:
-      - uses: actions/download-artifact@v8
-        with:
-          path: dist
-          merge-multiple: true
-
-      - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          skip-existing: true
diff --git a/.github/workflows/publish-manually.yml b/.github/workflows/publish-manually.yml
index 83ed290a2b..2f15c6ecda 100644
--- a/.github/workflows/publish-manually.yml
+++ b/.github/workflows/publish-manually.yml
@@ -39,15 +39,17 @@ on:
 jobs:
   build-and-publish:
     name: "Build wheels"
-    uses: ./.github/workflows/lib-build-and-push.yml
+    uses: ./.github/workflows/lib-build.yml
     with:
-      upload: false
       python-version: ${{ inputs.python-version }}
       ignore_tests: ${{ inputs.ignore_tests }}
       target_tag: ${{ inputs.target_tag }}
       target: ${{ inputs.target }}
 
-  # TODO: Remove when https://github.com/pypa/gh-action-pypi-publish/issues/166 is fixed and update build-and-publish.with.upload to ${{ inputs.upload }}
+  # Publishing is a separate job (not inside the reusable workflow) because PyPI Trusted Publishing
+  # requires the *caller* workflow path in the OIDC token. A reusable workflow would embed its own
+  # path instead, causing an `invalid-publisher` error on the PyPI side.
+  # See: https://github.com/pypa/gh-action-pypi-publish/issues/166
   publish:
     name: "Publish wheels to PyPi"
     needs: build-and-publish

From 3aa5935de1ef89cbc58ef24d4aaeb9d1fad10a4f Mon Sep 17 00:00:00 2001
From: Mikita Hradovich <mikita.hradovich@scylladb.com>
Date: Fri, 17 Apr 2026 11:27:01 +0200
Subject: [PATCH 24/49] CI: remove ineffective GITHUB_WORKFLOW_REF override
 from cibuildwheel steps

GITHUB_WORKFLOW_REF was set as a shell env var prefix on the cibuildwheel
invocations as an attempted workaround for pypa/gh-action-pypi-publish#166
(reusable workflows not supported by PyPI Trusted Publishing).

The workaround does not work for two reasons:
1. GITHUB_WORKFLOW_REF is a GitHub runner-provided variable used to populate
   the OIDC token. Setting it in a child process's environment has no effect
   on the token GitHub's infrastructure mints.
2. The OIDC token is minted when pypa/gh-action-pypi-publish runs (in the
   publish job), not when cibuildwheel runs (in build-wheels). The variable
   was set in the wrong job entirely.

The actual working workaround is running pypa/gh-action-pypi-publish directly
in the caller workflow (build-push.yml, publish-manually.yml), which is already
done. This variable override is dead code with no effect.
---
 .github/workflows/lib-build.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/lib-build.yml b/.github/workflows/lib-build.yml
index f8d0d7a4cc..bc094d1b11 100644
--- a/.github/workflows/lib-build.yml
+++ b/.github/workflows/lib-build.yml
@@ -140,12 +140,12 @@ jobs:
         if: matrix.target != 'linux-aarch64'
         shell: bash
         run: |
-          GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build.yml@refs/heads/master" cibuildwheel --output-dir wheelhouse
+          cibuildwheel --output-dir wheelhouse
 
       - name: Build wheels for linux aarch64
         if: matrix.target == 'linux-aarch64'
         run: |
-          GITHUB_WORKFLOW_REF="scylladb/python-driver/.github/workflows/lib-build.yml@refs/heads/master" CIBW_BUILD="cp3*" cibuildwheel --archs aarch64 --output-dir wheelhouse
+          CIBW_BUILD="cp3*" cibuildwheel --archs aarch64 --output-dir wheelhouse
 
       - uses: actions/upload-artifact@v7
         with:

From 5cd0158e1775e6ce27148fe733a9030ca4d3bfa4 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Tue, 21 Apr 2026 19:38:23 +0000
Subject: [PATCH 25/49] chore(deps): update astral-sh/setup-uv action to v8

---
 .github/workflows/docs-pages.yml        | 2 +-
 .github/workflows/docs-pr.yml           | 2 +-
 .github/workflows/integration-tests.yml | 2 +-
 .github/workflows/lib-build.yml         | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/docs-pages.yml b/.github/workflows/docs-pages.yml
index 0da86fef34..9d14b9c4d8 100644
--- a/.github/workflows/docs-pages.yml
+++ b/.github/workflows/docs-pages.yml
@@ -31,7 +31,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@v8.1.0
         with:
           working-directory: docs
           enable-cache: true
diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index 4158c2912e..f0aa64d628 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -37,7 +37,7 @@ jobs:
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@v8.1.0
         with:
           working-directory: docs
           enable-cache: true
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 89f62963b0..fde1ab3e1d 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -68,7 +68,7 @@ jobs:
       run: sudo apt-get install libev4 libev-dev
 
     - name: Install uv
-      uses: astral-sh/setup-uv@v7
+      uses: astral-sh/setup-uv@v8.1.0
       with:
         python-version: ${{ matrix.python-version }}
 
diff --git a/.github/workflows/lib-build.yml b/.github/workflows/lib-build.yml
index bc094d1b11..21dcc0604f 100644
--- a/.github/workflows/lib-build.yml
+++ b/.github/workflows/lib-build.yml
@@ -96,7 +96,7 @@ jobs:
           echo "CIBW_BEFORE_TEST_WINDOWS=(exit 0)" >> $GITHUB_ENV;
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@v8.1.0
         with:
           python-version: ${{ inputs.python-version }}
 
@@ -159,7 +159,7 @@ jobs:
       - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v7
+        uses: astral-sh/setup-uv@v8.1.0
         with:
           python-version: ${{ inputs.python-version }}
 

From 32548a66010ac1fa3fa722afe3abf39469ff281c Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Tue, 14 Apr 2026 20:03:56 +0300
Subject: [PATCH 26/49] Fix unfilled format string in add_execution_profile
 timeout message

The error message at Cluster.add_execution_profile() had an unfilled %s
placeholder: 'Failed to create all new connection pools in the %ss timeout.'
The pool_wait_timeout value was never interpolated into the string, so
users would see a literal '%s' instead of the actual timeout value.

Signed-off-by: Yaniv Kaul <yaniv.kaul@scylladb.com>
---
 cassandra/cluster.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cassandra/cluster.py b/cassandra/cluster.py
index 9eace8810d..4f07f023a3 100644
--- a/cassandra/cluster.py
+++ b/cassandra/cluster.py
@@ -1683,7 +1683,7 @@ def add_execution_profile(self, name, profile, pool_wait_timeout=5):
             futures.update(session.update_created_pools())
         _, not_done = wait_futures(futures, pool_wait_timeout)
         if not_done:
-            raise OperationTimedOut("Failed to create all new connection pools in the %ss timeout.")
+            raise OperationTimedOut("Failed to create all new connection pools in the %ss timeout." % pool_wait_timeout)
 
     def connection_factory(self, endpoint, host_conn = None, *args, **kwargs):
         """

From d83adab0857caf3cd288244a0b56c28cbba83a32 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Tue, 14 Apr 2026 20:39:49 +0300
Subject: [PATCH 27/49] Add timeout and in-flight observability to
 OperationTimedOut
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Improve timeout observability in the driver, inspired by the Go driver
PR scylladb/gocql#847.

OperationTimedOut now carries optional timeout and in_flight fields that
are appended to the exception message when present (e.g.
"(timeout=10.0s, in_flight=42)"). All seven production raise sites in
connection.py and cluster.py pass these values where available.

Additionally, debug-level log lines are emitted for:
- Client-side request timeouts (host, timeout, in_flight, orphaned)
- Server-side read/write timeouts (host, consistency, received/required,
  data_retrieved/write_type, retry decision)

A helper _retry_decision_name() translates RetryPolicy constants to
human-readable strings for the log messages.

New keyword-only parameters are backward compatible — existing callers
that pass only positional errors/last_host continue to work unchanged.

Fixes: DRIVER-538

Signed-off-by: Yaniv Kaul <yaniv.kaul@scylladb.com>
---
 cassandra/__init__.py              | 21 ++++++++++-
 cassandra/cluster.py               | 16 ++++++---
 cassandra/connection.py            | 15 +++++---
 tests/unit/test_cluster.py         | 58 ++++++++++++++++++++++++++++++
 tests/unit/test_connection.py      |  2 ++
 tests/unit/test_response_future.py | 12 +++++--
 6 files changed, 112 insertions(+), 12 deletions(-)

diff --git a/cassandra/__init__.py b/cassandra/__init__.py
index 3ad8fcdfd1..46de7daaf0 100644
--- a/cassandra/__init__.py
+++ b/cassandra/__init__.py
@@ -687,10 +687,29 @@ class OperationTimedOut(DriverException):
     The last :class:`~.Host` this operation was attempted against.
     """
 
-    def __init__(self, errors=None, last_host=None):
+    timeout = None
+    """
+    The timeout value (in seconds) that was in effect when the operation
+    timed out, or ``None`` if not applicable.
+    """
+
+    in_flight = None
+    """
+    The number of in-flight requests on the connection at the time of
+    the timeout (includes orphaned requests), or ``None`` if not applicable.
+    """
+
+    def __init__(self, errors=None, last_host=None, timeout=None, in_flight=None):
         self.errors = errors
         self.last_host = last_host
+        self.timeout = timeout
+        self.in_flight = in_flight
         message = "errors=%s, last_host=%s" % (self.errors, self.last_host)
+        if self.timeout is not None:
+            message += " (timeout=%ss" % self.timeout
+            if self.in_flight is not None:
+                message += ", in_flight=%d" % self.in_flight
+            message += ")"
         Exception.__init__(self, message)
 
 
diff --git a/cassandra/cluster.py b/cassandra/cluster.py
index 4f07f023a3..5e7a68bc1c 100644
--- a/cassandra/cluster.py
+++ b/cassandra/cluster.py
@@ -191,7 +191,6 @@ def _connection_reduce_fn(val,import_fn):
 
 log = logging.getLogger(__name__)
 
-
 _GRAPH_PAGING_MIN_DSE_VERSION = Version('6.8.0')
 
 _NOT_SET = object()
@@ -1683,7 +1682,8 @@ def add_execution_profile(self, name, profile, pool_wait_timeout=5):
             futures.update(session.update_created_pools())
         _, not_done = wait_futures(futures, pool_wait_timeout)
         if not_done:
-            raise OperationTimedOut("Failed to create all new connection pools in the %ss timeout." % pool_wait_timeout)
+            raise OperationTimedOut("Failed to create all new connection pools in the %ss timeout." % pool_wait_timeout,
+                                    timeout=pool_wait_timeout)
 
     def connection_factory(self, endpoint, host_conn = None, *args, **kwargs):
         """
@@ -4505,6 +4505,7 @@ def _on_timeout(self, _attempts=0):
             )
             return
 
+        conn_in_flight = None
         if self._connection is not None:
             try:
                 self._connection._requests.pop(self._req_id)
@@ -4515,9 +4516,14 @@ def _on_timeout(self, _attempts=0):
             except KeyError:
                 key = "Connection defunct by heartbeat"
                 errors = {key: "Client request timeout. See Session.execute[_async](timeout)"}
-                self._set_final_exception(OperationTimedOut(errors, self._current_host))
+                self._set_final_exception(OperationTimedOut(errors, self._current_host,
+                                                            timeout=self.timeout,
+                                                            in_flight=self._connection.in_flight))
                 return
 
+            # Capture connection stats before pool.return_connection() can alter state
+            conn_in_flight = self._connection.in_flight
+
             pool = self.session._pools.get(self._current_host)
             if pool and not pool.is_shutdown:
                 # Do not return the stream ID to the pool yet. We cannot reuse it
@@ -4542,7 +4548,9 @@ def _on_timeout(self, _attempts=0):
                 host = str(connection.endpoint) if connection else 'unknown'
                 errors = {host: "Request timed out while waiting for schema agreement. See Session.execute[_async](timeout) and Cluster.max_schema_agreement_wait."}
 
-        self._set_final_exception(OperationTimedOut(errors, self._current_host))
+        self._set_final_exception(OperationTimedOut(errors, self._current_host,
+                                                    timeout=self.timeout,
+                                                    in_flight=conn_in_flight))
 
     def _on_speculative_execute(self):
         self._timer = None
diff --git a/cassandra/connection.py b/cassandra/connection.py
index c045b36cb3..08501d0a2b 100644
--- a/cassandra/connection.py
+++ b/cassandra/connection.py
@@ -984,7 +984,8 @@ def factory(cls, endpoint, timeout, host_conn = None, *args, **kwargs):
             raise conn.last_error
         elif not conn.connected_event.is_set():
             conn.close()
-            raise OperationTimedOut("Timed out creating connection (%s seconds)" % timeout)
+            raise OperationTimedOut("Timed out creating connection (%s seconds)" % timeout,
+                                    timeout=timeout)
         else:
             return conn
 
@@ -1247,6 +1248,7 @@ def wait_for_responses(self, *msgs, **kwargs):
                 msg += ": %s" % (self.last_error,)
             raise ConnectionShutdown(msg)
         timeout = kwargs.get('timeout')
+        original_timeout = timeout  # preserve for exception reporting
         fail_on_error = kwargs.get('fail_on_error', True)
         waiter = ResponseWaiter(self, len(msgs), fail_on_error)
 
@@ -1271,7 +1273,8 @@ def wait_for_responses(self, *msgs, **kwargs):
                 if timeout is not None:
                     timeout -= 0.01
                     if timeout <= 0.0:
-                        raise OperationTimedOut()
+                        raise OperationTimedOut(timeout=original_timeout,
+                                                in_flight=self.in_flight)
                 time.sleep(0.01)
 
         try:
@@ -1796,7 +1799,8 @@ def deliver(self, timeout=None):
         if self.error:
             raise self.error
         elif not self.event.is_set():
-            raise OperationTimedOut()
+            raise OperationTimedOut(timeout=timeout,
+                                    in_flight=self.connection.in_flight)
         else:
             return self.responses
 
@@ -1823,7 +1827,10 @@ def wait(self, timeout):
             if self._exception:
                 raise self._exception
         else:
-            raise OperationTimedOut("Connection heartbeat timeout after %s seconds" % (timeout,), self.connection.endpoint)
+            raise OperationTimedOut("Connection heartbeat timeout after %s seconds" % (timeout,),
+                                    self.connection.endpoint,
+                                    timeout=timeout,
+                                    in_flight=self.connection.in_flight)
 
     def _options_callback(self, response):
         if isinstance(response, SupportedMessage):
diff --git a/tests/unit/test_cluster.py b/tests/unit/test_cluster.py
index 872d133b28..a4f0ebc4d3 100644
--- a/tests/unit/test_cluster.py
+++ b/tests/unit/test_cluster.py
@@ -87,6 +87,64 @@ def test_exception_types(self):
         assert issubclass(UnsupportedOperation, DriverException)
 
 
+class OperationTimedOutTest(unittest.TestCase):
+
+    def test_message_without_timeout(self):
+        """Default message format when no timeout info is provided."""
+        exc = OperationTimedOut(errors={'host1': 'some error'}, last_host='host1')
+        msg = str(exc)
+        assert "errors={'host1': 'some error'}" in msg
+        assert "last_host=host1" in msg
+        assert "timeout=" not in msg
+        assert "in_flight=" not in msg
+
+    def test_message_with_timeout_and_in_flight(self):
+        """Message includes timeout and in_flight when both are provided."""
+        exc = OperationTimedOut(errors={'host1': 'err'}, last_host='host1',
+                                timeout=10.0, in_flight=42)
+        msg = str(exc)
+        assert "(timeout=10.0s, in_flight=42)" in msg
+
+    def test_message_with_timeout_no_in_flight(self):
+        """Message includes timeout but not in_flight when only timeout is set."""
+        exc = OperationTimedOut(timeout=5.0)
+        msg = str(exc)
+        assert "(timeout=5.0s)" in msg
+        assert "in_flight=" not in msg
+
+    def test_message_no_args(self):
+        """No-argument form should not crash and should have clean message."""
+        exc = OperationTimedOut()
+        msg = str(exc)
+        assert "errors=None, last_host=None" in msg
+        assert "timeout=" not in msg
+
+    def test_attributes_accessible(self):
+        """New and existing attributes should be readable."""
+        exc = OperationTimedOut(errors={'h': 'e'}, last_host='h',
+                                timeout=10.0, in_flight=42)
+        assert exc.errors == {'h': 'e'}
+        assert exc.last_host == 'h'
+        assert exc.timeout == 10.0
+        assert exc.in_flight == 42
+
+    def test_attributes_default_none(self):
+        """New attributes should default to None when not provided."""
+        exc = OperationTimedOut()
+        assert exc.timeout is None
+        assert exc.in_flight is None
+        assert exc.errors is None
+        assert exc.last_host is None
+
+    def test_backward_compat_positional(self):
+        """Existing two-positional-arg form should still work."""
+        exc = OperationTimedOut({'h': 'err'}, 'host1')
+        assert exc.errors == {'h': 'err'}
+        assert exc.last_host == 'host1'
+        assert exc.timeout is None
+        assert exc.in_flight is None
+
+
 class ClusterTest(unittest.TestCase):
 
     def test_tuple_for_contact_points(self):
diff --git a/tests/unit/test_connection.py b/tests/unit/test_connection.py
index a67b7e4678..2fa7c71196 100644
--- a/tests/unit/test_connection.py
+++ b/tests/unit/test_connection.py
@@ -520,6 +520,8 @@ def send_msg(msg, req_id, msg_callback):
         assert isinstance(exc, OperationTimedOut)
         assert exc.errors == 'Connection heartbeat timeout after 0.05 seconds'
         assert exc.last_host == DefaultEndPoint('localhost')
+        assert exc.timeout == 0.05
+        assert isinstance(exc.in_flight, int)
         holder.return_connection.assert_has_calls(
             [call(connection)] * get_holders.call_count)
 
diff --git a/tests/unit/test_response_future.py b/tests/unit/test_response_future.py
index 7168ad2940..dd7fa75045 100644
--- a/tests/unit/test_response_future.py
+++ b/tests/unit/test_response_future.py
@@ -142,6 +142,8 @@ def test_heartbeat_defunct_deadlock(self):
 
         connection = MagicMock(spec=Connection)
         connection._requests = {}
+        connection.in_flight = 5
+        connection.orphaned_request_ids = set()
 
         pool = Mock()
         pool.is_shutdown = False
@@ -162,8 +164,10 @@ def test_heartbeat_defunct_deadlock(self):
 
         # Simulate ResponseFuture timing out
         rf._on_timeout()
-        with pytest.raises(OperationTimedOut, match="Connection defunct by heartbeat"):
+        with pytest.raises(OperationTimedOut, match="Connection defunct by heartbeat") as exc_info:
             rf.result()
+        assert exc_info.value.timeout == 1
+        assert exc_info.value.in_flight == 5
 
     def test_read_timeout_error_message(self):
         session = self.make_session()
@@ -653,7 +657,7 @@ def test_timeout_does_not_release_stream_id(self):
         pool = self.make_pool()
         session._pools.get.return_value = pool
         connection = Mock(spec=Connection, lock=RLock(), _requests={}, request_ids=deque(),
-                orphaned_request_ids=set(), orphaned_threshold=256)
+                orphaned_request_ids=set(), orphaned_threshold=256, in_flight=3)
         pool.borrow_connection.return_value = (connection, 1)
 
         rf = self.make_response_future(session)
@@ -663,8 +667,10 @@ def test_timeout_does_not_release_stream_id(self):
 
         rf._on_timeout()
         pool.return_connection.assert_called_once_with(connection, stream_was_orphaned=True)
-        with pytest.raises(OperationTimedOut, match="Client request timeout"):
+        with pytest.raises(OperationTimedOut, match="Client request timeout") as exc_info:
             rf.result()
+        assert exc_info.value.timeout == 1
+        assert exc_info.value.in_flight == 3
 
         assert len(connection.request_ids) == 0, \
             "Request IDs should be empty but it's not: {}".format(connection.request_ids)

From ea6078954b1278d2b3c5af74fd199efbdfbbc9fa Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 31 Jan 2026 22:33:08 +0000
Subject: [PATCH 28/49] Add tests for libev atexit cleanup bug

- Added test_libevreactor_shutdown.py to demonstrate the bug
- Tests show that atexit callback captures None instead of actual loop

Co-authored-by: fruch <340979+fruch@users.noreply.github.com>
---
 tests/unit/io/test_libevreactor_shutdown.py | 250 ++++++++++++++++++++
 1 file changed, 250 insertions(+)
 create mode 100644 tests/unit/io/test_libevreactor_shutdown.py

diff --git a/tests/unit/io/test_libevreactor_shutdown.py b/tests/unit/io/test_libevreactor_shutdown.py
new file mode 100644
index 0000000000..6be2c2b647
--- /dev/null
+++ b/tests/unit/io/test_libevreactor_shutdown.py
@@ -0,0 +1,250 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Test to demonstrate the libevwrapper atexit cleanup issue.
+
+This test demonstrates the problem where the atexit callback is registered
+with _global_loop=None at import time, causing it to receive None during
+shutdown instead of the actual loop instance.
+"""
+
+import unittest
+import atexit
+import sys
+import subprocess
+import tempfile
+import os
+from pathlib import Path
+
+from cassandra import DependencyException
+
+try:
+    from cassandra.io.libevreactor import LibevConnection
+except (ImportError, DependencyException):
+    LibevConnection = None
+
+from tests import is_monkey_patched
+
+
+class LibevAtexitCleanupTest(unittest.TestCase):
+    """
+    Test case to demonstrate the atexit cleanup bug in libevreactor.
+    
+    The bug: atexit.register(partial(_cleanup, _global_loop)) is called when
+    _global_loop is None, so the cleanup function receives None at shutdown
+    instead of the actual LibevLoop instance that was created later.
+    """
+
+    def setUp(self):
+        if is_monkey_patched():
+            raise unittest.SkipTest("Can't test libev with monkey patching")
+        if LibevConnection is None:
+            raise unittest.SkipTest('libev does not appear to be installed correctly')
+
+    def test_atexit_callback_registered_with_none(self):
+        """
+        Test that demonstrates the atexit callback bug.
+        
+        The atexit.register(partial(_cleanup, _global_loop)) line is executed
+        when _global_loop is None. This means the partial function captures
+        None as the argument, and when atexit calls it during shutdown, it
+        passes None to _cleanup instead of the actual loop instance.
+        
+        @since 3.29
+        @jira_ticket PYTHON-XXX
+        @expected_result The test demonstrates that atexit cleanup is broken
+        
+        @test_category connection
+        """
+        from cassandra.io import libevreactor
+        from functools import partial
+        
+        # Check the current atexit handlers
+        # Note: atexit._exithandlers is an implementation detail but useful for debugging
+        if hasattr(atexit, '_exithandlers'):
+            # Find our cleanup handler
+            cleanup_handler = None
+            for handler in atexit._exithandlers:
+                func = handler[0]
+                # Check if this is our partial(_cleanup, _global_loop) handler
+                if isinstance(func, partial):
+                    if func.func.__name__ == '_cleanup':
+                        cleanup_handler = func
+                        break
+            
+            if cleanup_handler:
+                # The problem: the partial was created with _global_loop=None
+                # So even if _global_loop is later set to a LibevLoop instance,
+                # the atexit callback will still call _cleanup(None)
+                captured_arg = cleanup_handler.args[0] if cleanup_handler.args else None
+                
+                # This assertion will fail after LibevConnection.initialize_reactor()
+                # is called and _global_loop is set to a LibevLoop instance
+                LibevConnection.initialize_reactor()
+                
+                # At this point, libevreactor._global_loop is not None
+                self.assertIsNotNone(libevreactor._global_loop,
+                                   "Global loop should be initialized")
+                
+                # But the atexit handler still has None captured!
+                self.assertIsNone(captured_arg,
+                                "The atexit handler captured None, not the actual loop instance. "
+                                "This is the BUG: cleanup will receive None at shutdown!")
+                
+    def test_shutdown_crash_scenario_subprocess(self):
+        """
+        Test that simulates a Python shutdown crash scenario in a subprocess.
+        
+        This test creates a minimal script that:
+        1. Imports the driver
+        2. Creates a connection (which starts the event loop)
+        3. Exits without explicit cleanup
+        
+        The expected behavior is that atexit should clean up the loop, but
+        because of the bug, the cleanup receives None and doesn't actually
+        stop the loop or its watchers. This can lead to crashes if callbacks
+        fire during shutdown.
+        
+        @since 3.29
+        @jira_ticket PYTHON-XXX
+        @expected_result The subprocess demonstrates the cleanup issue
+        
+        @test_category connection
+        """
+        # Create a test script that demonstrates the issue
+        test_script = '''
+import sys
+import os
+
+# Add the driver path
+sys.path.insert(0, {driver_path!r})
+
+# Import and setup
+from cassandra.io.libevreactor import LibevConnection, _global_loop
+import atexit
+
+# Initialize the reactor (creates the global loop)
+LibevConnection.initialize_reactor()
+
+print("Global loop initialized:", _global_loop is not None)
+
+# Check what atexit will actually call
+if hasattr(atexit, '_exithandlers'):
+    from functools import partial
+    for handler in atexit._exithandlers:
+        func = handler[0]
+        if isinstance(func, partial) and func.func.__name__ == '_cleanup':
+            captured_arg = func.args[0] if func.args else None
+            print("Atexit will call _cleanup with:", captured_arg)
+            print("But _global_loop is:", _global_loop)
+            print("BUG: Cleanup will receive None instead of the loop!")
+            break
+
+# Exit without explicit cleanup - atexit should handle it, but won't!
+print("Exiting...")
+'''
+        
+        driver_path = str(Path(__file__).parent.parent.parent.parent)
+        script_content = test_script.format(driver_path=driver_path)
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write(script_content)
+            script_path = f.name
+        
+        try:
+            result = subprocess.run(
+                [sys.executable, script_path],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            output = result.stdout
+            print("\n=== Subprocess Output ===")
+            print(output)
+            print("=== End Output ===\n")
+            
+            # Verify the output shows the bug
+            self.assertIn("Global loop initialized: True", output)
+            self.assertIn("Atexit will call _cleanup with: None", output)
+            self.assertIn("BUG: Cleanup will receive None instead of the loop!", output)
+            
+        finally:
+            os.unlink(script_path)
+
+
+class LibevShutdownRaceConditionTest(unittest.TestCase):
+    """
+    Tests to analyze potential race conditions and crashes during shutdown.
+    """
+
+    def setUp(self):
+        if is_monkey_patched():
+            raise unittest.SkipTest("Can't test libev with monkey patching")
+        if LibevConnection is None:
+            raise unittest.SkipTest('libev does not appear to be installed correctly')
+
+    def test_callback_during_shutdown_scenario(self):
+        """
+        Test to document the potential crash scenario.
+        
+        When Python is shutting down:
+        1. Various modules are being torn down
+        2. The libev event loop may still be running
+        3. If a callback (io_callback, timer_callback, prepare_callback) fires:
+           - It calls PyGILState_Ensure()
+           - It tries to call Python functions (PyObject_CallFunction)
+           - If Python objects have been deallocated, this can crash
+        
+        The root cause: The atexit cleanup doesn't actually run because it
+        receives None instead of the loop instance, so it never:
+        - Sets _shutdown flag
+        - Stops watchers
+        - Joins the event loop thread
+        
+        @since 3.29
+        @jira_ticket PYTHON-XXX
+        @expected_result Documents the crash scenario
+        
+        @test_category connection
+        """
+        from cassandra.io.libevreactor import _global_loop, _cleanup
+        
+        # This test documents the issue - we can't easily reproduce a crash
+        # in a unit test without actually tearing down Python, but we can
+        # verify the conditions that lead to it
+        
+        LibevConnection.initialize_reactor()
+        
+        # Verify the loop exists
+        self.assertIsNotNone(_global_loop)
+        
+        # Simulate what atexit would call (with the bug)
+        _cleanup(None)  # BUG: receives None instead of _global_loop
+        
+        # The loop is still running because cleanup did nothing!
+        self.assertFalse(_global_loop._shutdown,
+                        "Loop should NOT be shut down when cleanup receives None")
+        
+        # Now call it correctly
+        _cleanup(_global_loop)
+        
+        # Now it should be shut down
+        self.assertTrue(_global_loop._shutdown,
+                       "Loop should be shut down when cleanup receives the actual loop")
+
+
+if __name__ == '__main__':
+    unittest.main()

From 9ce7024930a96d1ee52f69ff2cb80ae7a8740a97 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 3 Feb 2026 12:06:05 +0000
Subject: [PATCH 29/49] Implement Solution 1: Fix atexit registration to
 prevent shutdown crashes

This implements the minimal fix for the libev atexit cleanup bug.

Changes:
- Replace atexit.register(partial(_cleanup, _global_loop)) with a wrapper
  function _atexit_cleanup() that looks up _global_loop at shutdown time
- Remove unused 'partial' import from functools
- Update tests to verify the fix works correctly

The bug was that partial() captured _global_loop=None at import time, so
cleanup always received None at shutdown instead of the actual LibevLoop
instance. This prevented proper cleanup, leaving active callbacks that
could crash during Python interpreter shutdown.

The fix ensures _global_loop is looked up when atexit calls the cleanup,
not when the callback is registered, so cleanup receives the actual loop
instance and can properly shut down watchers and join the event loop thread.

Co-authored-by: fruch <340979+fruch@users.noreply.github.com>
---
 cassandra/io/libevreactor.py                |  15 +-
 tests/unit/io/test_libevreactor_shutdown.py | 198 +++++++++-----------
 2 files changed, 105 insertions(+), 108 deletions(-)

diff --git a/cassandra/io/libevreactor.py b/cassandra/io/libevreactor.py
index c3f8f967ee..3da809931f 100644
--- a/cassandra/io/libevreactor.py
+++ b/cassandra/io/libevreactor.py
@@ -13,7 +13,6 @@
 # limitations under the License.
 import atexit
 from collections import deque
-from functools import partial
 import logging
 import os
 import socket
@@ -232,8 +231,20 @@ def _loop_will_run(self, prepare):
             self._notifier.send()
 
 
+def _atexit_cleanup():
+    """Cleanup function called by atexit that uses the current _global_loop value.
+    
+    This wrapper ensures that cleanup receives the actual LibevLoop instance
+    instead of None, which was the value of _global_loop when the module was
+    imported.
+    """
+    global _global_loop
+    if _global_loop is not None:
+        _cleanup(_global_loop)
+
+
 _global_loop = None
-atexit.register(partial(_cleanup, _global_loop))
+atexit.register(_atexit_cleanup)
 
 
 class LibevConnection(Connection):
diff --git a/tests/unit/io/test_libevreactor_shutdown.py b/tests/unit/io/test_libevreactor_shutdown.py
index 6be2c2b647..5c44bca3aa 100644
--- a/tests/unit/io/test_libevreactor_shutdown.py
+++ b/tests/unit/io/test_libevreactor_shutdown.py
@@ -21,7 +21,6 @@
 """
 
 import unittest
-import atexit
 import sys
 import subprocess
 import tempfile
@@ -53,77 +52,67 @@ def setUp(self):
         if LibevConnection is None:
             raise unittest.SkipTest('libev does not appear to be installed correctly')
 
-    def test_atexit_callback_registered_with_none(self):
+    def test_atexit_callback_uses_current_global_loop(self):
         """
-        Test that demonstrates the atexit callback bug.
+        Test that verifies the atexit callback fix.
         
-        The atexit.register(partial(_cleanup, _global_loop)) line is executed
-        when _global_loop is None. This means the partial function captures
-        None as the argument, and when atexit calls it during shutdown, it
-        passes None to _cleanup instead of the actual loop instance.
+        The fix uses a wrapper function _atexit_cleanup() that looks up the
+        current value of _global_loop at shutdown time, instead of capturing
+        it at import time with partial().
         
         @since 3.29
         @jira_ticket PYTHON-XXX
-        @expected_result The test demonstrates that atexit cleanup is broken
+        @expected_result The atexit handler calls cleanup with the actual loop
         
         @test_category connection
         """
         from cassandra.io import libevreactor
-        from functools import partial
         
-        # Check the current atexit handlers
-        # Note: atexit._exithandlers is an implementation detail but useful for debugging
-        if hasattr(atexit, '_exithandlers'):
-            # Find our cleanup handler
-            cleanup_handler = None
-            for handler in atexit._exithandlers:
-                func = handler[0]
-                # Check if this is our partial(_cleanup, _global_loop) handler
-                if isinstance(func, partial):
-                    if func.func.__name__ == '_cleanup':
-                        cleanup_handler = func
-                        break
-            
-            if cleanup_handler:
-                # The problem: the partial was created with _global_loop=None
-                # So even if _global_loop is later set to a LibevLoop instance,
-                # the atexit callback will still call _cleanup(None)
-                captured_arg = cleanup_handler.args[0] if cleanup_handler.args else None
-                
-                # This assertion will fail after LibevConnection.initialize_reactor()
-                # is called and _global_loop is set to a LibevLoop instance
-                LibevConnection.initialize_reactor()
-                
-                # At this point, libevreactor._global_loop is not None
-                self.assertIsNotNone(libevreactor._global_loop,
-                                   "Global loop should be initialized")
-                
-                # But the atexit handler still has None captured!
-                self.assertIsNone(captured_arg,
-                                "The atexit handler captured None, not the actual loop instance. "
-                                "This is the BUG: cleanup will receive None at shutdown!")
-                
-    def test_shutdown_crash_scenario_subprocess(self):
+        # Verify the fix: _atexit_cleanup should exist as a module-level function
+        self.assertTrue(hasattr(libevreactor, '_atexit_cleanup'),
+                       "Module should have _atexit_cleanup function")
+
+        # Verify it's not a partial (the old buggy implementation)
+        from functools import partial
+        self.assertNotIsInstance(libevreactor._atexit_cleanup, partial,
+                                "The _atexit_cleanup should NOT be a partial function")
+
+        # Verify it's actually a function
+        self.assertTrue(callable(libevreactor._atexit_cleanup),
+                       "_atexit_cleanup should be callable")
+
+        # Initialize the reactor
+        LibevConnection.initialize_reactor()
+
+        # At this point, libevreactor._global_loop is not None
+        self.assertIsNotNone(libevreactor._global_loop,
+                           "Global loop should be initialized")
+
+        # The fix: _atexit_cleanup is a function that will look up
+        # _global_loop when it's called, not a partial with captured args
+        self.assertEqual(libevreactor._atexit_cleanup.__name__, '_atexit_cleanup',
+                        "The function should have the correct name")
+
+    def test_shutdown_cleanup_works_with_fix(self):
         """
-        Test that simulates a Python shutdown crash scenario in a subprocess.
+        Test that verifies the atexit cleanup fix works in a subprocess.
         
         This test creates a minimal script that:
         1. Imports the driver
-        2. Creates a connection (which starts the event loop)
-        3. Exits without explicit cleanup
+        2. Initializes the reactor (creates the global loop)
+        3. Verifies the _atexit_cleanup function is available
+        4. Exits without explicit cleanup
         
-        The expected behavior is that atexit should clean up the loop, but
-        because of the bug, the cleanup receives None and doesn't actually
-        stop the loop or its watchers. This can lead to crashes if callbacks
-        fire during shutdown.
+        With the fix, atexit should properly clean up the loop using the
+        wrapper function that looks up _global_loop at shutdown time.
         
         @since 3.29
         @jira_ticket PYTHON-XXX
-        @expected_result The subprocess demonstrates the cleanup issue
+        @expected_result The subprocess shows the fix is working
         
         @test_category connection
         """
-        # Create a test script that demonstrates the issue
+        # Create a test script that verifies the fix
         test_script = '''
 import sys
 import os
@@ -132,28 +121,29 @@ def test_shutdown_crash_scenario_subprocess(self):
 sys.path.insert(0, {driver_path!r})
 
 # Import and setup
-from cassandra.io.libevreactor import LibevConnection, _global_loop
+from cassandra.io import libevreactor
+from cassandra.io.libevreactor import LibevConnection
 import atexit
 
 # Initialize the reactor (creates the global loop)
 LibevConnection.initialize_reactor()
 
-print("Global loop initialized:", _global_loop is not None)
-
-# Check what atexit will actually call
-if hasattr(atexit, '_exithandlers'):
-    from functools import partial
-    for handler in atexit._exithandlers:
-        func = handler[0]
-        if isinstance(func, partial) and func.func.__name__ == '_cleanup':
-            captured_arg = func.args[0] if func.args else None
-            print("Atexit will call _cleanup with:", captured_arg)
-            print("But _global_loop is:", _global_loop)
-            print("BUG: Cleanup will receive None instead of the loop!")
-            break
-
-# Exit without explicit cleanup - atexit should handle it, but won't!
-print("Exiting...")
+print("Global loop initialized:", libevreactor._global_loop is not None)
+
+# Verify the fix is in place: _atexit_cleanup should be a module-level function
+if hasattr(libevreactor, '_atexit_cleanup'):
+    print("FIXED: Module has _atexit_cleanup function")
+    print("This function will look up _global_loop at shutdown time")
+    # Verify it's not using partial with None
+    import inspect
+    source = inspect.getsource(libevreactor._atexit_cleanup)
+    if "global _global_loop" in source and "_global_loop is not None" in source:
+        print("Verified: _atexit_cleanup uses current _global_loop value")
+else:
+    print("BUG: No _atexit_cleanup function found")
+
+# Exit without explicit cleanup - atexit should handle it properly with the fix!
+print("Exiting with proper cleanup...")
 '''
         
         driver_path = str(Path(__file__).parent.parent.parent.parent)
@@ -176,11 +166,12 @@ def test_shutdown_crash_scenario_subprocess(self):
             print(output)
             print("=== End Output ===\n")
             
-            # Verify the output shows the bug
+            # Verify the output shows the fix is working
             self.assertIn("Global loop initialized: True", output)
-            self.assertIn("Atexit will call _cleanup with: None", output)
-            self.assertIn("BUG: Cleanup will receive None instead of the loop!", output)
-            
+            self.assertIn("FIXED: Module has _atexit_cleanup function", output)
+            self.assertIn("Verified: _atexit_cleanup uses current _global_loop value", output)
+            self.assertNotIn("BUG", output.replace("BUG STILL PRESENT", "").replace("DEBUG", ""))  # Allow "BUG" only in success message
+
         finally:
             os.unlink(script_path)
 
@@ -196,54 +187,49 @@ def setUp(self):
         if LibevConnection is None:
             raise unittest.SkipTest('libev does not appear to be installed correctly')
 
-    def test_callback_during_shutdown_scenario(self):
+    def test_cleanup_with_fix_properly_shuts_down(self):
         """
-        Test to document the potential crash scenario.
-        
-        When Python is shutting down:
-        1. Various modules are being torn down
-        2. The libev event loop may still be running
-        3. If a callback (io_callback, timer_callback, prepare_callback) fires:
-           - It calls PyGILState_Ensure()
-           - It tries to call Python functions (PyObject_CallFunction)
-           - If Python objects have been deallocated, this can crash
-        
-        The root cause: The atexit cleanup doesn't actually run because it
-        receives None instead of the loop instance, so it never:
-        - Sets _shutdown flag
-        - Stops watchers
-        - Joins the event loop thread
+        Test to verify the fix properly shuts down the event loop.
+        
+        With the fix in place, the atexit cleanup will:
+        1. Look up the current _global_loop value (not None)
+        2. Call _cleanup with the actual loop instance
+        3. Properly shut down the loop and its watchers
+        
+        This prevents the crash scenario where:
+        - Various modules are being torn down during Python shutdown
+        - The libev event loop is still running
+        - Callbacks fire and try to access deallocated Python objects
         
         @since 3.29
         @jira_ticket PYTHON-XXX
-        @expected_result Documents the crash scenario
+        @expected_result Cleanup properly shuts down the loop with the fix
         
         @test_category connection
         """
-        from cassandra.io.libevreactor import _global_loop, _cleanup
-        
-        # This test documents the issue - we can't easily reproduce a crash
-        # in a unit test without actually tearing down Python, but we can
-        # verify the conditions that lead to it
-        
+        from cassandra.io import libevreactor
+        from cassandra.io.libevreactor import _cleanup, _atexit_cleanup
+
         LibevConnection.initialize_reactor()
         
         # Verify the loop exists
-        self.assertIsNotNone(_global_loop)
-        
-        # Simulate what atexit would call (with the bug)
-        _cleanup(None)  # BUG: receives None instead of _global_loop
+        self.assertIsNotNone(libevreactor._global_loop)
+
+        # Before cleanup, the loop should not be shut down
+        self.assertFalse(libevreactor._global_loop._shutdown,
+                        "Loop should not be shut down initially")
         
-        # The loop is still running because cleanup did nothing!
-        self.assertFalse(_global_loop._shutdown,
+        # Simulate what the OLD buggy code would do
+        _cleanup(None)  # This does nothing
+        self.assertFalse(libevreactor._global_loop._shutdown,
                         "Loop should NOT be shut down when cleanup receives None")
         
-        # Now call it correctly
-        _cleanup(_global_loop)
+        # Now test the FIX: call the wrapper that looks up _global_loop
+        _atexit_cleanup()  # This is what atexit will actually call
         
-        # Now it should be shut down
-        self.assertTrue(_global_loop._shutdown,
-                       "Loop should be shut down when cleanup receives the actual loop")
+        # With the fix, the loop should be properly shut down
+        self.assertTrue(libevreactor._global_loop._shutdown,
+                       "Loop should be shut down when _atexit_cleanup is called")
 
 
 if __name__ == '__main__':

From cd9f525140bd47311841fbe54ca59940f7ff6821 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sun, 22 Feb 2026 03:13:24 +0000
Subject: [PATCH 30/49] Update copyright header to ScyllaDB in
 test_libevreactor_shutdown.py

Changed copyright from DataStax to ScyllaDB to match the project's
standard for new files, as requested by reviewer.

Co-authored-by: dkropachev <40304587+dkropachev@users.noreply.github.com>
---
 tests/unit/io/test_libevreactor_shutdown.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/io/test_libevreactor_shutdown.py b/tests/unit/io/test_libevreactor_shutdown.py
index 5c44bca3aa..9578d22df1 100644
--- a/tests/unit/io/test_libevreactor_shutdown.py
+++ b/tests/unit/io/test_libevreactor_shutdown.py
@@ -1,4 +1,4 @@
-# Copyright DataStax, Inc.
+# Copyright ScyllaDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

From 0842348d647b35ae0ec1d87ba906ec81adaec5f7 Mon Sep 17 00:00:00 2001
From: Israel Fruchter <fruch@scylladb.com>
Date: Mon, 4 May 2026 21:04:01 +0300
Subject: [PATCH 31/49] fix(build): use dict-style license for setuptools<77
 compatibility

The PEP 639 SPDX string format (license = "Apache-2.0") requires
setuptools>=77. Downstream projects that constrain setuptools to <75
fail to build from source with "project.license must be valid exactly
by one definition (2 matches found)".

Switch to the dict-style format which is compatible with all
setuptools versions >=65.

Fixes #840
---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 1335027fcd..4a40af5378 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -21,7 +21,7 @@ classifiers = [
 ]
 dependencies = ['geomet>=1.1', 'pyyaml > 5.0']
 dynamic = ["version", "readme"]
-license = "Apache-2.0"
+license = {text = "Apache-2.0"}
 requires-python = ">=3.9"
 
 [project.urls]

From e6f9e9ff86579b8d8f1d068df93fb7e6af1c40c4 Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Wed, 6 May 2026 08:40:10 +0200
Subject: [PATCH 32/49] Remove oss/ent_scylla_version params from
 xfail_scylla_version_lt

xfail_scylla_version_lt now takes a single scylla_version parameter
instead of separate oss_scylla_version and ent_scylla_version params.
The enterprise/OSS version branching logic is removed; the decorator
simply compares the current version against the single provided version.

Update all call sites accordingly.
---
 tests/integration/__init__.py                     | 15 +++++----------
 .../integration/standard/test_application_info.py |  2 +-
 .../standard/test_control_connection.py           |  2 +-
 tests/integration/standard/test_metadata.py       |  2 +-
 4 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
index 286561c291..6a809bded4 100644
--- a/tests/integration/__init__.py
+++ b/tests/integration/__init__.py
@@ -687,29 +687,24 @@ def is_scylla_enterprise(version: Version) -> bool:
     return version > Version('2000.1.1')
 
 
-def xfail_scylla_version_lt(reason, oss_scylla_version, ent_scylla_version, *args, **kwargs):
+def xfail_scylla_version_lt(reason, scylla_version, *args, **kwargs):
     """
     It is used to mark tests that are going to fail on certain scylla versions.
     :param reason: message to fail test with
-    :param oss_scylla_version: str, oss version from which test supposed to succeed
-    :param ent_scylla_version: str, enterprise version from which test supposed to succeed
+    :param scylla_version: str, version from which test supposed to succeed
     """
     if not (reason.startswith("scylladb/scylladb#") or reason.startswith("scylladb/scylla-enterprise#")):
         raise ValueError('reason should start with scylladb/scylladb#<issue-id> or scylladb/scylla-enterprise#<issue-id> to reference issue in scylla repo')
 
-    if not isinstance(ent_scylla_version, str):
-        raise ValueError('ent_scylla_version should be a str')
+    if not isinstance(scylla_version, str):
+        raise ValueError('scylla_version should be a str')
 
     if SCYLLA_VERSION is None:
         return pytest.mark.skipif(False, reason="It is just a NoOP Decor, should not skip anything")
 
     current_version = Version(get_scylla_version(SCYLLA_VERSION))
 
-    if is_scylla_enterprise(current_version):
-        return pytest.mark.xfail(current_version < Version(ent_scylla_version),
-                                 reason=reason, *args, **kwargs)
-
-    return pytest.mark.xfail(current_version < Version(oss_scylla_version), reason=reason, *args, **kwargs)
+    return pytest.mark.xfail(current_version < Version(scylla_version), reason=reason, *args, **kwargs)
 
 
 def skip_scylla_version_lt(reason, scylla_version):
diff --git a/tests/integration/standard/test_application_info.py b/tests/integration/standard/test_application_info.py
index 719f37843a..5d4b679fc8 100644
--- a/tests/integration/standard/test_application_info.py
+++ b/tests/integration/standard/test_application_info.py
@@ -27,7 +27,7 @@ def teardown_module():
 
 
 @xfail_scylla_version_lt(reason='scylladb/scylla-enterprise#5467 - system.client_options is not yet supported',
-                             oss_scylla_version="7.0", ent_scylla_version="2026.1.0")
+                         scylla_version="2026.1.0")
 class ApplicationInfoTest(unittest.TestCase):
     attribute_to_startup_key = {
         'application_name': 'APPLICATION_NAME',
diff --git a/tests/integration/standard/test_control_connection.py b/tests/integration/standard/test_control_connection.py
index 2788a1d837..c4463e17fd 100644
--- a/tests/integration/standard/test_control_connection.py
+++ b/tests/integration/standard/test_control_connection.py
@@ -135,7 +135,7 @@ def test_control_connection_port_discovery(self):
             assert 7000 == host.broadcast_port
 
     @xfail_scylla_version_lt(reason='scylladb/scylladb#26992 - system.client_routes is not yet supported',
-                             oss_scylla_version="7.0", ent_scylla_version="2026.1.0")
+                             scylla_version="2026.1.0")
     def test_client_routes_change_event(self):
         cluster = TestCluster()
 
diff --git a/tests/integration/standard/test_metadata.py b/tests/integration/standard/test_metadata.py
index c30e369d83..6e64401a75 100644
--- a/tests/integration/standard/test_metadata.py
+++ b/tests/integration/standard/test_metadata.py
@@ -1197,7 +1197,7 @@ def test_export_keyspace_schema_udts(self):
 
     @greaterthancass21
     @xfail_scylla_version_lt(reason='scylladb/scylladb#10707 - Column name in CREATE INDEX is not quoted',
-                             oss_scylla_version="5.2", ent_scylla_version="2023.1.1")
+                             scylla_version="2023.1.1")
     def test_case_sensitivity(self):
         """
         Test that names that need to be escaped in CREATE statements are

From 0d215f45b33a8e2cf336c5f120915a318e47f606 Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Thu, 7 May 2026 00:46:12 -0400
Subject: [PATCH 33/49] cluster: add Session.wait_for_schema_agreement

Add Session.wait_for_schema_agreement() as a session-scoped schema agreement check. The new API queries schema_version from system.local on the connected hosts selected by the requested rack, dc, or cluster scope, respects Cluster.max_schema_agreement_wait and the control-connection metadata timeouts, and bounds the fan-out with configurable parallelism.

Update the public Session docs and switch the integration callers that were explicitly waiting on schema agreement to use the session API. Add unit coverage for agreement, retries, busy connections, missing pools, batching, scope filtering, and invalid scope handling.
---
 cassandra/cluster.py                        | 193 +++++++++++++++++-
 docs/api/cassandra/cluster.rst              |   2 +
 tests/integration/long/test_schema.py       |   2 +-
 tests/integration/standard/test_udts.py     |   2 +-
 tests/unit/test_cluster.py                  | 214 +++++++++++++++++++-
 tests/unit/test_session_schema_agreement.py | 204 +++++++++++++++++++
 6 files changed, 611 insertions(+), 6 deletions(-)
 create mode 100644 tests/unit/test_session_schema_agreement.py

diff --git a/cassandra/cluster.py b/cassandra/cluster.py
index 5e7a68bc1c..b55fbd5172 100644
--- a/cassandra/cluster.py
+++ b/cassandra/cluster.py
@@ -20,16 +20,17 @@
 
 import atexit
 import datetime
+from enum import Enum
 from binascii import hexlify
 from collections import defaultdict
 from collections.abc import Mapping
-from concurrent.futures import ThreadPoolExecutor, FIRST_COMPLETED, wait as wait_futures
+from concurrent.futures import Future, ThreadPoolExecutor, FIRST_COMPLETED, wait as wait_futures
 from copy import copy
 from functools import partial, reduce, wraps
 from itertools import groupby, count, chain
 import json
 import logging
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union, Tuple
 from warnings import warn
 from random import random
 import re
@@ -214,6 +215,14 @@ def __init__(self, message, errors):
         self.errors = errors
 
 
+class SchemaAgreementScope(str, Enum):
+    """Scope selectors for :meth:`.Session.wait_for_schema_agreement`."""
+
+    RACK = 'rack'
+    DC = 'dc'
+    CLUSTER = 'cluster'
+
+
 def _future_completed(future):
     """ Helper for run_in_executor() """
     exc = future.exception()
@@ -3374,6 +3383,185 @@ def pool_finished_setting_keyspace(pool, host_errors):
         for pool in tuple(self._pools.values()):
             pool._set_keyspace_for_all_conns(keyspace, pool_finished_setting_keyspace)
 
+    def wait_for_schema_agreement(self, wait_time: Optional[float] = None,
+                                  scope: SchemaAgreementScope = SchemaAgreementScope.CLUSTER) -> bool:
+        """
+        Wait for connected hosts in the selected scope to report the same
+        schema version from ``system.local``.
+
+        By default, the timeout for this operation is governed by
+        :attr:`~.Cluster.max_schema_agreement_wait` and
+        :attr:`~.Cluster.control_connection_timeout`.
+
+        Passing ``wait_time`` here overrides
+        :attr:`~.Cluster.max_schema_agreement_wait`. If provided, ``wait_time``
+        must be greater than 0.
+
+        ``scope`` determines which connected hosts participate in the check.
+        Pass :attr:`SchemaAgreementScope.RACK`, :attr:`SchemaAgreementScope.DC`,
+        or :attr:`SchemaAgreementScope.CLUSTER`.
+        The default is :attr:`SchemaAgreementScope.CLUSTER`. ``RACK`` narrows
+        the check to connected hosts in the local rack only. ``DC`` checks
+        connected hosts in the local datacenter. ``CLUSTER`` queries every
+        connected host across all datacenters.
+
+        :param wait_time: Override for
+            :attr:`~.Cluster.max_schema_agreement_wait`, should be positive
+            number.
+        :param scope: Restricts the check to connected hosts in the local rack,
+            local datacenter, or whole connected cluster.
+        :returns: ``True`` when the selected connected hosts agree on schema,
+            otherwise ``False``.
+        :raises ValueError: If ``wait_time`` is provided and is not greater
+            than 0.
+        :raises ValueError: If ``scope`` is not one of the schema agreement
+            scope values.
+        """
+
+        if wait_time is not None and wait_time <= 0:
+            raise ValueError("wait_time must be greater than 0")
+
+        total_timeout = wait_time if wait_time is not None else self.cluster.max_schema_agreement_wait
+        if total_timeout <= 0:
+            raise ValueError("total_timeout must be greater than 0")
+
+        deadline = time.time() + total_timeout
+        schema_mismatches = None
+        scope_label = 'local rack' if scope is SchemaAgreementScope.RACK else (
+            'local datacenter' if scope is SchemaAgreementScope.DC else 'cluster')
+
+        while time.time() < deadline:
+            schema_mismatches = self._get_schema_mismatches_for_scope(deadline, scope)
+            if schema_mismatches is None:
+                return True
+
+            log.debug("[session] Connected hosts in the %s still disagree on schema, trying again", scope_label)
+            remaining = deadline - time.time()
+            if remaining > 0:
+                time.sleep(min(0.2, remaining))
+
+        log.warning("[session] Connected hosts in the %s are reporting a schema disagreement: %s",
+                    scope_label, schema_mismatches)
+        return False
+
+    def _get_schema_mismatches_for_scope(self, deadline: float,
+                                         scope: SchemaAgreementScope) -> Optional[Dict[Any, Any]]:
+        hosts = self._get_schema_agreement_hosts(scope)
+        mismatches = defaultdict(list)
+        errors = {}
+        scope_label = 'local rack' if scope is SchemaAgreementScope.RACK else (
+            'local datacenter' if scope is SchemaAgreementScope.DC else 'cluster')
+
+        if not hosts:
+            errors[scope.value] = ConnectionException(
+                "No connected hosts available in the %s" % (scope_label,)
+            )
+            return {'unavailable': errors}
+
+        metadata_request_timeout = self.cluster.control_connection._metadata_request_timeout
+        query = maybe_add_timeout_to_query(ControlConnection._SELECT_SCHEMA_LOCAL, metadata_request_timeout)
+
+        schema_version_futures = []
+        for host in hosts:
+            try:
+                schema_version_future = self._query_local_schema_version(host, query, deadline)
+            except Exception as exc:
+                errors[host.endpoint] = exc
+                continue
+
+            schema_version_futures.append((host, schema_version_future))
+
+        if schema_version_futures:
+            # Start all host queries first, then wait for the whole batch.
+            remaining = max(0.0, deadline - time.time())
+            if remaining > 0:
+                wait_futures([future for _, future in schema_version_futures], timeout=remaining)
+
+            for host, future in schema_version_futures:
+                if future.done():
+                    try:
+                        rows = future.result()
+                    except Exception as exc:
+                        errors[host.endpoint] = exc
+                        continue
+
+                    row = rows.one()
+                    schema_version = getattr(row, "schema_version", None) if row is not None else None
+                    mismatches[schema_version].append(host.endpoint)
+                else:
+                    errors[host.endpoint] = OperationTimedOut(last_host=host, timeout=max(0.0, deadline - time.time()))
+
+        if len(mismatches) == 1 and None not in mismatches and not errors:
+            log.debug("[session] Connected hosts in the %s agree on schema", scope_label)
+            return None
+
+        if errors:
+            mismatches['unavailable'] = errors
+        return dict(mismatches)
+
+    def _get_schema_agreement_hosts(self, scope: SchemaAgreementScope) -> Tuple[Host, ...]:
+        if scope is SchemaAgreementScope.RACK:
+            allowed_distances = (HostDistance.LOCAL_RACK,)
+        elif scope is SchemaAgreementScope.DC:
+            allowed_distances = (HostDistance.LOCAL_RACK, HostDistance.LOCAL)
+        else:
+            allowed_distances = (HostDistance.LOCAL_RACK, HostDistance.LOCAL, HostDistance.REMOTE)
+
+        return tuple(
+            host for host, pool in tuple(self._pools.items())
+            if host.is_up
+            and not pool.is_shutdown
+            and self._profile_manager.distance(host) in allowed_distances)
+
+    def _query_local_schema_version(self, host: Host, query: str, deadline: float) -> Future:
+        remaining = max(0.0, deadline - time.time())
+        try:
+            response_future = self.execute_async(
+                query,
+                timeout=self._schema_agreement_query_timeout(remaining),
+                host=host,
+            )
+        except OperationTimedOut as timeout:
+            log.debug("[session] Timed out waiting for schema version from %s: %s", host, timeout)
+            raise
+        except Exception as exc:
+            log.debug("[session] Error querying schema version from %s: %s", host, exc)
+            raise
+
+        # execute_async returns cassandra.cluster.ResponseFuture, which does not have bulk waiting logic for it.
+        # That is why _query_local_schema_version returns concurrent.futures.Future
+        #  so that schema agreement logic could use concurrent.futures.wait_futures to wait on them.
+        # schema_version_future is an adapter between cassandra.cluster.ResponseFuture and concurrent.futures.Future
+        # to make things work
+        schema_version_future = Future()
+
+        def _set_result(result, result_future=schema_version_future, response_future=response_future):
+            if result_future.done():
+                return
+            try:
+                result_future.set_result(ResultSet(response_future, result))
+            except Exception as exc:
+                result_future.set_exception(exc)
+
+        def _set_exception(exc, result_future=schema_version_future):
+            if result_future.done():
+                return
+            result_future.set_exception(exc)
+
+        try:
+            response_future.add_callbacks(_set_result, _set_exception)
+        except Exception as exc:
+            log.debug("[session] Error registering schema version callback from %s: %s", host, exc)
+            raise
+
+        return schema_version_future
+
+    def _schema_agreement_query_timeout(self, remaining: float) -> float:
+        control_timeout = self.cluster.control_connection._timeout
+        if control_timeout is None:
+            return max(0.0, remaining)
+        return max(0.0, min(control_timeout, remaining))
+
     def user_type_registered(self, keyspace, user_type, klass):
         """
         Called by the parent Cluster instance when the user registers a new
@@ -4079,7 +4267,6 @@ def _handle_schema_change(self, event):
         self._cluster.scheduler.schedule_unique(delay, self.refresh_schema, **event)
 
     def wait_for_schema_agreement(self, connection=None, preloaded_results=None, wait_time=None):
-
         total_timeout = wait_time if wait_time is not None else self._cluster.max_schema_agreement_wait
         if total_timeout <= 0:
             return True
diff --git a/docs/api/cassandra/cluster.rst b/docs/api/cassandra/cluster.rst
index 51f03f3d97..de8518d271 100644
--- a/docs/api/cassandra/cluster.rst
+++ b/docs/api/cassandra/cluster.rst
@@ -169,6 +169,8 @@ Clusters and Sessions
 
    .. automethod:: set_keyspace(keyspace)
 
+   .. automethod:: wait_for_schema_agreement
+
    .. automethod:: get_execution_profile
 
    .. automethod:: execution_profile_clone_update
diff --git a/tests/integration/long/test_schema.py b/tests/integration/long/test_schema.py
index f892acba52..3b4dcd33d5 100644
--- a/tests/integration/long/test_schema.py
+++ b/tests/integration/long/test_schema.py
@@ -158,4 +158,4 @@ def check_and_wait_for_agreement(self, session, rs, exepected):
         time.sleep(1)
         assert rs.response_future.is_schema_agreed == exepected
         if not rs.response_future.is_schema_agreed:
-            session.cluster.control_connection.wait_for_schema_agreement(wait_time=1000)
+            session.wait_for_schema_agreement(wait_time=1000)
diff --git a/tests/integration/standard/test_udts.py b/tests/integration/standard/test_udts.py
index e608a9610b..18f3dfb298 100644
--- a/tests/integration/standard/test_udts.py
+++ b/tests/integration/standard/test_udts.py
@@ -147,7 +147,7 @@ def test_can_register_udt_before_connecting(self):
         c.register_user_type("udt_test_register_before_connecting2", "user", User2)
 
         s = c.connect(wait_for_all_pools=True)
-        c.control_connection.wait_for_schema_agreement()
+        s.wait_for_schema_agreement()
 
         s.execute("INSERT INTO udt_test_register_before_connecting.mytable (a, b) VALUES (%s, %s)", (0, User1(42, 'bob')))
         result = s.execute("SELECT b FROM udt_test_register_before_connecting.mytable WHERE a=0")
diff --git a/tests/unit/test_cluster.py b/tests/unit/test_cluster.py
index a4f0ebc4d3..b6f2da5372 100644
--- a/tests/unit/test_cluster.py
+++ b/tests/unit/test_cluster.py
@@ -15,14 +15,16 @@
 
 import logging
 import socket
+from types import SimpleNamespace
 
 from unittest.mock import patch, Mock
 import uuid
 
 from cassandra import ConsistencyLevel, DriverException, Timeout, Unavailable, RequestExecutionException, ReadTimeout, WriteTimeout, CoordinationFailure, ReadFailure, WriteFailure, FunctionFailure, AlreadyExists,\
     InvalidRequest, Unauthorized, AuthenticationFailed, OperationTimedOut, UnsupportedOperation, RequestValidationException, ConfigurationException, ProtocolVersion
-from cassandra.cluster import _Scheduler, Session, Cluster, default_lbp_factory, \
+from cassandra.cluster import _Scheduler, Session, Cluster, ResultSet, SchemaAgreementScope, default_lbp_factory, \
     ExecutionProfile, _ConfigMode, EXEC_PROFILE_DEFAULT
+from cassandra.connection import ConnectionBusy
 from cassandra.pool import Host
 from cassandra.policies import HostDistance, RetryPolicy, RoundRobinPolicy, DowngradingConsistencyRetryPolicy, SimpleConvictionPolicy
 from cassandra.query import SimpleStatement, named_tuple_factory, tuple_factory
@@ -247,11 +249,123 @@ def test_event_delay_timing(self, *_):
 
 
 class SessionTest(unittest.TestCase):
+    class FakeTime(object):
+
+        def __init__(self):
+            self.clock = 0
+
+        def time(self):
+            return self.clock
+
+        def sleep(self, amount):
+            self.clock += amount
+
+    class MockPool(object):
+
+        def __init__(self, host, connection):
+            self.host = host
+            self.host_distance = HostDistance.LOCAL
+            self.is_shutdown = False
+            self.connection = connection
+
+        def _get_connection_for_routing_key(self):
+            return self.connection
+
+    class MockSchemaVersionFuture(object):
+
+        def __init__(self, outcome, auto_complete=True):
+            self._outcome = outcome
+            self._auto_complete = auto_complete
+            self._delivered = False
+            self._callback_state = None
+            self._col_names = ("schema_version",)
+            self._col_types = None
+            self.has_more_pages = False
+            self._continuous_paging_session = None
+
+        def _deliver(self):
+            if self._delivered or self._callback_state is None:
+                return
+
+            self._delivered = True
+            callback, errback, callback_args, callback_kwargs, errback_args, errback_kwargs = self._callback_state
+            if isinstance(self._outcome, Exception):
+                errback(self._outcome, *errback_args, **errback_kwargs)
+            else:
+                row = SimpleNamespace(schema_version=self._outcome)
+                callback([row], *callback_args, **callback_kwargs)
+
+        def add_callbacks(self, callback, errback,
+                          callback_args=(), callback_kwargs=None,
+                          errback_args=(), errback_kwargs=None):
+            self._callback_state = (
+                callback,
+                errback,
+                callback_args,
+                callback_kwargs or {},
+                errback_args,
+                errback_kwargs or {},
+            )
+            if self._auto_complete:
+                self._deliver()
+            return self
+
+        def complete(self):
+            self._deliver()
+
+        def result(self):
+            if isinstance(self._outcome, Exception):
+                raise self._outcome
+            return ResultSet(self, [SimpleNamespace(schema_version=self._outcome)])
+
     def setUp(self):
         if connection_class is None:
             raise unittest.SkipTest('libev does not appear to be installed correctly')
         connection_class.initialize_reactor()
 
+    def _mock_schema_future(self, outcome):
+        return self.MockSchemaVersionFuture(outcome)
+
+    def _host_query_count(self, session, target_host):
+        return sum(1 for call in session.execute_async.call_args_list if call.kwargs.get('host') is target_host)
+
+    def _new_schema_agreement_session(self, schema_versions, distances=None):
+        hosts = []
+        connections = {}
+        distance_map = {}
+        if distances is None:
+            distances = [HostDistance.LOCAL] * len(schema_versions)
+
+        for index, schema_version in enumerate(schema_versions):
+            host = Host("127.0.0.%d" % (index + 1), SimpleConvictionPolicy, host_id=uuid.uuid4())
+            host.set_up()
+            hosts.append(host)
+            distance_map[host] = distances[index]
+
+        cluster = Cluster(protocol_version=4)
+        for host in hosts:
+            cluster.metadata.add_or_return_host(host)
+
+        session = Session(cluster, hosts)
+        session._profile_manager.distance = Mock(side_effect=lambda host: distance_map.get(host, HostDistance.LOCAL))
+        session._pools = {}
+        for host, schema_version in zip(hosts, schema_versions):
+            connection = Mock(endpoint=host.endpoint)
+            connection.future_outcomes = [schema_version]
+            session._pools[host] = self.MockPool(host, connection)
+            connections[host] = connection
+
+        def execute_async(query, parameters=None, trace=False,
+                            custom_payload=None, execution_profile=None,
+                            paging_state=None, timeout=None, host=None, execute_as=None):
+            connection = connections[host]
+            outcome = connection.future_outcomes.pop(0) if len(connection.future_outcomes) > 1 else connection.future_outcomes[0]
+            return self._mock_schema_future(outcome)
+
+        session.execute_async = Mock(side_effect=execute_async)
+
+        return session, hosts, connections
+
     # TODO: this suite could be expanded; for now just adding a test covering a PR
     @mock_session_pools
     def test_default_serial_consistency_level_ep(self, *_):
@@ -339,6 +453,104 @@ def test_set_keyspace_escapes_quotes(self, *_):
         assert query == 'USE simple_ks', (
             "Simple keyspace names should not be quoted, got: %r" % query)
 
+    @mock_session_pools
+    def test_wait_for_schema_agreement_default_scope_queries_all_connected_hosts(self, *_):
+        session, hosts, _ = self._new_schema_agreement_session(
+            ["a", "a"],
+            distances=[HostDistance.LOCAL_RACK, HostDistance.REMOTE])
+
+        assert session.wait_for_schema_agreement(wait_time=1)
+
+        for host in hosts:
+            assert self._host_query_count(session, host) == 1
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_retries_until_local_hosts_match(self, *_):
+        session, hosts, connections = self._new_schema_agreement_session(["a", "b"])
+        clock = self.FakeTime()
+        connections[hosts[1]].future_outcomes = ["b", "a"]
+
+        with patch('cassandra.cluster.time', new=clock):
+            assert session.wait_for_schema_agreement(wait_time=1)
+        for host in hosts:
+            assert self._host_query_count(session, host) == 2
+        assert clock.clock == 0.2
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_retries_when_local_connection_is_busy(self, *_):
+        session, hosts, connections = self._new_schema_agreement_session(["a", "a"])
+        clock = self.FakeTime()
+        connections[hosts[1]].future_outcomes = [
+            ConnectionBusy("connection overloaded"),
+            "a"]
+
+        with patch('cassandra.cluster.time', new=clock):
+            assert session.wait_for_schema_agreement(wait_time=1)
+        for host in hosts:
+            assert self._host_query_count(session, host) == 2
+        assert clock.clock == 0.2
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_ignores_local_hosts_without_session_pool(self, *_):
+        session, hosts, _ = self._new_schema_agreement_session(["a"])
+
+        unconnected_host = Host("127.0.0.2", SimpleConvictionPolicy, host_id=uuid.uuid4())
+        unconnected_host.set_up()
+        session.cluster.metadata.add_or_return_host(unconnected_host)
+
+        assert session.wait_for_schema_agreement(wait_time=1)
+        assert self._host_query_count(session, hosts[0]) == 1
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_queries_hosts_in_order(self, *_):
+        session, hosts, _ = self._new_schema_agreement_session(["a"] * 11)
+
+        assert session.wait_for_schema_agreement(wait_time=1)
+        assert [call.kwargs['host'] for call in session.execute_async.call_args_list] == list(hosts)
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_rack_scope_only_queries_local_rack_connections(self, *_):
+        session, hosts, _ = self._new_schema_agreement_session(
+            ["a", "a", "a"],
+            distances=[HostDistance.LOCAL_RACK, HostDistance.LOCAL, HostDistance.REMOTE])
+
+        assert session.wait_for_schema_agreement(wait_time=1, scope=SchemaAgreementScope.RACK)
+
+        assert self._host_query_count(session, hosts[0]) == 1
+        assert self._host_query_count(session, hosts[1]) == 0
+        assert self._host_query_count(session, hosts[2]) == 0
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_cluster_scope_skips_ignored_hosts(self, *_):
+        session, hosts, _ = self._new_schema_agreement_session(
+            ["a", "a"],
+            distances=[HostDistance.IGNORED, HostDistance.LOCAL])
+
+        assert session.wait_for_schema_agreement(wait_time=1, scope=SchemaAgreementScope.CLUSTER)
+
+        assert self._host_query_count(session, hosts[0]) == 0
+        assert self._host_query_count(session, hosts[1]) == 1
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_cluster_scope_excludes_hosts_with_unknown_status(self, *_):
+        session, hosts, _ = self._new_schema_agreement_session(
+            ["a", "a"],
+            distances=[HostDistance.LOCAL_RACK, HostDistance.LOCAL])
+
+        hosts[0].is_up = None
+
+        assert session.wait_for_schema_agreement(wait_time=1, scope=SchemaAgreementScope.CLUSTER)
+
+        assert self._host_query_count(session, hosts[0]) == 0
+        assert self._host_query_count(session, hosts[1]) == 1
+
+    @mock_session_pools
+    def test_wait_for_schema_agreement_rejects_unknown_scope(self, *_):
+        session, _, _ = self._new_schema_agreement_session(["a"])
+
+        with pytest.raises(ValueError):
+            session.wait_for_schema_agreement(wait_time=1, scope='planet')
+
 class ProtocolVersionTests(unittest.TestCase):
 
     def test_protocol_downgrade_test(self):
diff --git a/tests/unit/test_session_schema_agreement.py b/tests/unit/test_session_schema_agreement.py
new file mode 100644
index 0000000000..ffad687fcc
--- /dev/null
+++ b/tests/unit/test_session_schema_agreement.py
@@ -0,0 +1,204 @@
+from datetime import timedelta
+from types import SimpleNamespace
+from unittest.mock import Mock
+import uuid
+
+import pytest
+
+import cassandra.cluster as cluster_module
+from cassandra.connection import ConnectionBusy
+from cassandra.cluster import ControlConnection, Session, ResultSet
+from cassandra.policies import HostDistance, SimpleConvictionPolicy
+from cassandra.pool import Host
+from cassandra.util import maybe_add_timeout_to_query
+
+
+class FakeTime:
+    def __init__(self):
+        self.clock = 0
+
+    def time(self):
+        return self.clock
+
+    def sleep(self, amount):
+        self.clock += amount
+
+
+class MockPool:
+    def __init__(self, host):
+        self.host = host
+        self.is_shutdown = False
+
+
+class MockSchemaVersionFuture:
+    def __init__(self, outcome, auto_complete=True):
+        self._outcome = outcome
+        self._auto_complete = auto_complete
+        self._delivered = False
+        self._callback_state = None
+        self._col_names = ("schema_version",)
+        self._col_types = None
+        self.has_more_pages = False
+        self._continuous_paging_session = None
+
+    def _deliver(self):
+        if self._delivered or self._callback_state is None:
+            return
+
+        self._delivered = True
+        callback, errback, callback_args, callback_kwargs, errback_args, errback_kwargs = self._callback_state
+        if isinstance(self._outcome, Exception):
+            errback(self._outcome, *errback_args, **errback_kwargs)
+        else:
+            row = SimpleNamespace(schema_version=self._outcome)
+            callback([row], *callback_args, **callback_kwargs)
+
+    def add_callbacks(self, callback, errback,
+                      callback_args=(), callback_kwargs=None,
+                      errback_args=(), errback_kwargs=None):
+        self._callback_state = (
+            callback,
+            errback,
+            callback_args,
+            callback_kwargs or {},
+            errback_args,
+            errback_kwargs or {},
+        )
+        if self._auto_complete:
+            self._deliver()
+        return self
+
+    def complete(self):
+        self._deliver()
+
+    def result(self):
+        if isinstance(self._outcome, Exception):
+            raise self._outcome
+        return ResultSet(self, [SimpleNamespace(schema_version=self._outcome)])
+
+
+def _host_query_count(session, target_host):
+    return sum(1 for call in session.execute_async.call_args_list if call.kwargs.get("host") is target_host)
+
+
+def _new_session(schema_versions, distances=None, metadata_request_timeout=timedelta(seconds=2), timeout=2.0):
+    hosts = []
+    connections = {}
+    distance_map = {}
+
+    if distances is None:
+        distances = [HostDistance.LOCAL] * len(schema_versions)
+
+    for index, schema_version in enumerate(schema_versions):
+        host = Host("127.0.0.%d" % (index + 1), SimpleConvictionPolicy, host_id=uuid.uuid4())
+        host.set_up()
+        hosts.append(host)
+        distance_map[host] = distances[index]
+
+    cluster = SimpleNamespace(
+        max_schema_agreement_wait=10,
+        control_connection=SimpleNamespace(
+            _timeout=timeout,
+            _metadata_request_timeout=metadata_request_timeout,
+        ),
+    )
+
+    session = Session.__new__(Session)
+    session.cluster = cluster
+    session._profile_manager = SimpleNamespace(distance=lambda host: distance_map.get(host, HostDistance.LOCAL))
+    session._pools = {}
+    session.is_shutdown = False
+
+    for host, schema_version in zip(hosts, schema_versions):
+        connection = Mock(endpoint=host.endpoint)
+        connection.future_outcomes = [schema_version]
+        session._pools[host] = MockPool(host)
+        connections[host] = connection
+
+    def execute_async(query, parameters=None, trace=False,
+                     custom_payload=None, execution_profile=None,
+                     paging_state=None, timeout=None, host=None, execute_as=None):
+        connection = connections[host]
+        outcome = connection.future_outcomes.pop(0) if len(connection.future_outcomes) > 1 else connection.future_outcomes[0]
+        return MockSchemaVersionFuture(outcome)
+
+    session.execute_async = Mock(side_effect=execute_async)
+
+    return session, hosts, connections
+
+
+def test_wait_for_schema_agreement_retries_with_module_time(monkeypatch):
+    session, hosts, connections = _new_session(["a", "b"])
+    clock = FakeTime()
+    monkeypatch.setattr(cluster_module, "time", clock)
+    connections[hosts[1]].future_outcomes = ["b", "a"]
+
+    assert session.wait_for_schema_agreement(wait_time=1)
+    assert clock.clock == pytest.approx(0.2)
+    for host in hosts:
+        assert _host_query_count(session, host) == 2
+
+
+@pytest.mark.parametrize("wait_time", [0, -1])
+def test_wait_for_schema_agreement_rejects_non_positive_wait_time(wait_time):
+    session, _, _ = _new_session(["a"])
+
+    with pytest.raises(ValueError, match="wait_time must be greater than 0"):
+        session.wait_for_schema_agreement(wait_time=wait_time)
+
+    assert session.execute_async.call_count == 0
+
+
+def test_wait_for_schema_agreement_returns_false_when_no_hosts_match_scope(monkeypatch):
+    session, _, _ = _new_session(["a"], distances=[HostDistance.IGNORED])
+    clock = FakeTime()
+    monkeypatch.setattr(cluster_module, "time", clock)
+
+    assert session.wait_for_schema_agreement(wait_time=1) is False
+    assert session.execute_async.call_count == 0
+    assert clock.clock == pytest.approx(1.0)
+
+
+def test_wait_for_schema_agreement_uses_host_targeted_session_queries():
+    session, hosts, _ = _new_session(["a", "a"])
+
+    assert session.wait_for_schema_agreement(wait_time=0.1)
+
+    expected_query = maybe_add_timeout_to_query(
+        ControlConnection._SELECT_SCHEMA_LOCAL,
+        timedelta(seconds=2),
+    )
+    assert session.execute_async.call_count == 2
+    assert [call.args[0] for call in session.execute_async.call_args_list] == [expected_query, expected_query]
+    assert [call.kwargs["host"] for call in session.execute_async.call_args_list] == hosts
+    for call in session.execute_async.call_args_list:
+        assert 0 < call.kwargs["timeout"] <= 0.1
+
+
+def test_wait_for_schema_agreement_retries_after_host_targeted_query_error(monkeypatch):
+    session, hosts, connections = _new_session(["a", "a"])
+    clock = FakeTime()
+    monkeypatch.setattr(cluster_module, "time", clock)
+    connections[hosts[1]].future_outcomes = [ConnectionBusy("connection overloaded"), "a"]
+
+    assert session.wait_for_schema_agreement(wait_time=1)
+    assert clock.clock == pytest.approx(0.2)
+    for host in hosts:
+        assert _host_query_count(session, host) == 2
+
+
+def test_wait_for_schema_agreement_queries_hosts_in_order_under_one_deadline(monkeypatch):
+    session, hosts, _ = _new_session(["a", "a", "a"])
+    clock = FakeTime()
+    monkeypatch.setattr(cluster_module, "time", clock)
+
+    def execute_async(query, parameters=None, trace=False,
+                     custom_payload=None, execution_profile=None,
+                     paging_state=None, timeout=None, host=None, execute_as=None):
+        clock.sleep(0.01)
+        return MockSchemaVersionFuture("a")
+
+    session.execute_async = Mock(side_effect=execute_async)
+
+    assert session.wait_for_schema_agreement(wait_time=1)
+    assert [call.kwargs["host"] for call in session.execute_async.call_args_list] == hosts

From ef7c2d0f2ae557210cdb738f2587bcb2d97fddd7 Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Thu, 7 May 2026 00:46:34 -0400
Subject: [PATCH 34/49] control-connection: deprecate
 ControlConnection.wait_for_schema_agreement

Keep ControlConnection.wait_for_schema_agreement() as a compatibility wrapper, but move the existing implementation to _wait_for_schema_agreement() and deprecate the public method in favor of Session.wait_for_schema_agreement(). This lets the control-connection refresh path continue using the old logic internally without emitting warnings.

The control-connection wait path was designed for internal metadata refresh use, not as a user-facing schema agreement API.
It observes schema agreement from one single node, assuming that schema change statement have been ran on that host.
Using it by users will lead to false positives, if user ran statement on
a host different from host of control connection.

Update the unit tests to call the internal helper everywhere a warning is not expected, add explicit deprecation coverage for the public wrapper, and set stacklevel=2 so the warning points at the caller instead of inside the driver.
---
 cassandra/cluster.py                  | 26 ++++++++++++++++++++-
 tests/unit/test_control_connection.py | 33 +++++++++++++++++++--------
 2 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/cassandra/cluster.py b/cassandra/cluster.py
index b55fbd5172..483843c2a6 100644
--- a/cassandra/cluster.py
+++ b/cassandra/cluster.py
@@ -3974,7 +3974,7 @@ def _refresh_schema(self, connection, preloaded_results=None, schema_agreement_w
         if self._cluster.is_shutdown:
             return False
 
-        agreed = self.wait_for_schema_agreement(connection,
+        agreed = self._wait_for_schema_agreement(connection=connection,
                                                 preloaded_results=preloaded_results,
                                                 wait_time=schema_agreement_wait)
 
@@ -4267,6 +4267,30 @@ def _handle_schema_change(self, event):
         self._cluster.scheduler.schedule_unique(delay, self.refresh_schema, **event)
 
     def wait_for_schema_agreement(self, connection=None, preloaded_results=None, wait_time=None):
+        """
+        Wait for schema agreement from the control connection's metadata view.
+
+        This method is intended for internal metadata refresh flows. External
+        callers should use :meth:`.Session.wait_for_schema_agreement` instead.
+
+        The control connection observes schema agreement from its own
+        perspective, which may include hosts the session is not using, and it
+        may fail when the control connection itself is transiently unhealthy.
+        That can produce false positives or failures that do not reflect
+        whether a session can safely proceed.
+
+        .. deprecated:: 3.30.0
+           Use :meth:`.Session.wait_for_schema_agreement` instead.
+        """
+        warn("ControlConnection.wait_for_schema_agreement is deprecated and will be removed in 4.0. "
+             "Use Session.wait_for_schema_agreement instead. "
+             "This method is for internal metadata refresh use only.",
+             DeprecationWarning, stacklevel=2)
+        return self._wait_for_schema_agreement(connection=connection,
+                                               preloaded_results=preloaded_results,
+                                               wait_time=wait_time)
+
+    def _wait_for_schema_agreement(self, connection=None, preloaded_results=None, wait_time=None):
         total_timeout = wait_time if wait_time is not None else self._cluster.max_schema_agreement_wait
         if total_timeout <= 0:
             return True
diff --git a/tests/unit/test_control_connection.py b/tests/unit/test_control_connection.py
index 037d4a8888..fd62323f33 100644
--- a/tests/unit/test_control_connection.py
+++ b/tests/unit/test_control_connection.py
@@ -15,7 +15,7 @@
 import unittest
 
 from concurrent.futures import ThreadPoolExecutor
-from unittest.mock import Mock, ANY, call
+from unittest.mock import Mock, ANY, call, patch
 
 from cassandra import OperationTimedOut, SchemaTargetType, SchemaChangeType
 from cassandra.protocol import ResultMessage, RESULT_KIND_ROWS
@@ -210,16 +210,27 @@ def test_wait_for_schema_agreement(self):
         """
         Basic test with all schema versions agreeing
         """
-        assert self.control_connection.wait_for_schema_agreement()
+        assert self.control_connection._wait_for_schema_agreement()
         # the control connection should not have slept at all
         assert self.time.clock == 0
 
+    @patch('cassandra.cluster.warn')
+    def test_wait_for_schema_agreement_warns_about_deprecation(self, mocked_warn):
+        assert self.control_connection.wait_for_schema_agreement()
+
+        mocked_warn.assert_called_once()
+        warning_args, warning_kwargs = mocked_warn.call_args
+        assert 'ControlConnection.wait_for_schema_agreement is deprecated' in str(warning_args[0])
+        assert 'Use Session.wait_for_schema_agreement instead.' in str(warning_args[0])
+        assert warning_args[1] is DeprecationWarning
+        assert warning_kwargs['stacklevel'] == 2
+
     def test_wait_for_schema_agreement_uses_preloaded_results_if_given(self):
         """
         wait_for_schema_agreement uses preloaded results if given for shared table queries
         """
         preloaded_results = self._matching_schema_preloaded_results
-        assert self.control_connection.wait_for_schema_agreement(preloaded_results=preloaded_results)
+        assert self.control_connection._wait_for_schema_agreement(preloaded_results=preloaded_results)
         # the control connection should not have slept at all
         assert self.time.clock == 0
         # the connection should not have made any queries if given preloaded results
@@ -230,7 +241,7 @@ def test_wait_for_schema_agreement_falls_back_to_querying_if_schemas_dont_match_
         wait_for_schema_agreement requery if schema does not match using preloaded results
         """
         preloaded_results = self._nonmatching_schema_preloaded_results
-        assert self.control_connection.wait_for_schema_agreement(preloaded_results=preloaded_results)
+        assert self.control_connection._wait_for_schema_agreement(preloaded_results=preloaded_results)
         # the control connection should not have slept at all
         assert self.time.clock == 0
         assert self.connection.wait_for_responses.call_count == 1
@@ -241,7 +252,7 @@ def test_wait_for_schema_agreement_fails(self):
         """
         # change the schema version on one node
         self.connection.peer_results[1][1][2] = 'b'
-        assert not self.control_connection.wait_for_schema_agreement()
+        assert not self.control_connection._wait_for_schema_agreement()
         # the control connection should have slept until it hit the limit
         assert self.time.clock >= self.cluster.max_schema_agreement_wait
 
@@ -262,7 +273,7 @@ def test_wait_for_schema_agreement_skipping(self):
         self.connection.peer_results[1][1][3] = 'c'
         self.cluster.metadata.get_host(DefaultEndPoint('192.168.1.1')).is_up = False
 
-        assert self.control_connection.wait_for_schema_agreement()
+        assert self.control_connection._wait_for_schema_agreement()
         assert self.time.clock == 0
 
     def test_wait_for_schema_agreement_rpc_lookup(self):
@@ -279,12 +290,12 @@ def test_wait_for_schema_agreement_rpc_lookup(self):
 
         # even though the new host has a different schema version, it's
         # marked as down, so the control connection shouldn't care
-        assert self.control_connection.wait_for_schema_agreement()
+        assert self.control_connection._wait_for_schema_agreement()
         assert self.time.clock == 0
 
         # but once we mark it up, the control connection will care
         host.is_up = True
-        assert not self.control_connection.wait_for_schema_agreement()
+        assert not self.control_connection._wait_for_schema_agreement()
         assert self.time.clock >= self.cluster.max_schema_agreement_wait
 
 
@@ -299,7 +310,7 @@ def test_wait_for_schema_agreement_none_timeout(self):
                                status_event_refresh_window=0)
         cc._connection = self.connection
         cc._time = self.time
-        assert cc.wait_for_schema_agreement()
+        assert cc._wait_for_schema_agreement()
 
     def test_refresh_nodes_and_tokens(self):
         self.control_connection.refresh_node_list_and_token_map()
@@ -441,7 +452,8 @@ def bad_wait_for_responses(*args, **kwargs):
         self.control_connection.refresh_node_list_and_token_map()
         self.cluster.executor.submit.assert_called_with(self.control_connection._reconnect)
 
-    def test_refresh_schema_timeout(self):
+    @patch('cassandra.cluster.warn')
+    def test_refresh_schema_timeout(self, mocked_warn):
 
         def bad_wait_for_responses(*args, **kwargs):
             self.time.sleep(kwargs['timeout'])
@@ -451,6 +463,7 @@ def bad_wait_for_responses(*args, **kwargs):
         self.control_connection.refresh_schema()
         assert self.connection.wait_for_responses.call_count == self.cluster.max_schema_agreement_wait / self.control_connection._timeout
         assert self.connection.wait_for_responses.call_args[1]['timeout'] == self.control_connection._timeout
+        mocked_warn.assert_not_called()
 
     def test_handle_topology_change(self):
         event = {

From 51dd3668d6d16339832e2fc22fd7112dfb636670 Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Thu, 7 May 2026 09:55:28 -0400
Subject: [PATCH 35/49] connection: clean up failed heartbeat sends

Keep heartbeat request-id and in-flight bookkeeping consistent when send_msg() fails.\n\nHandle the control-connection in_flight release separately from HostConnection cleanup.
---
 cassandra/connection.py       | 14 +++++++++++++-
 tests/unit/test_connection.py | 27 ++++++++++++++++++++++++++-
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/cassandra/connection.py b/cassandra/connection.py
index 08501d0a2b..f07160e385 100644
--- a/cassandra/connection.py
+++ b/cassandra/connection.py
@@ -1816,7 +1816,19 @@ def __init__(self, connection, owner):
         with connection.lock:
             if connection.in_flight < connection.max_request_id:
                 connection.in_flight += 1
-                connection.send_msg(OptionsMessage(), connection.get_request_id(), self._options_callback)
+                request_id = connection.get_request_id()
+                try:
+                    connection.send_msg(OptionsMessage(), request_id, self._options_callback)
+                except Exception as exc:
+                    if connection.is_control_connection:
+                        connection.in_flight -= 1
+                    # send_msg() registers the callback before writing to the socket,
+                    # so a write failure must unwind that registration here.
+                    connection._requests.pop(request_id, None)
+                    if request_id not in connection.request_ids:
+                        connection.request_ids.append(request_id)
+                    self._exception = exc
+                    self._event.set()
             else:
                 self._exception = Exception("Failed to send heartbeat because connection 'in_flight' exceeds threshold")
                 self._event.set()
diff --git a/tests/unit/test_connection.py b/tests/unit/test_connection.py
index 2fa7c71196..cf4607fbed 100644
--- a/tests/unit/test_connection.py
+++ b/tests/unit/test_connection.py
@@ -21,7 +21,7 @@
 from cassandra import OperationTimedOut
 from cassandra.cluster import Cluster
 from cassandra.connection import (Connection, HEADER_DIRECTION_TO_CLIENT, ProtocolError,
-                                  locally_supported_compressions, ConnectionHeartbeat, _Frame, Timer, TimerManager,
+                                  locally_supported_compressions, ConnectionHeartbeat, HeartbeatFuture, _Frame, Timer, TimerManager,
                                   ConnectionException, ConnectionShutdown, DefaultEndPoint, ShardAwarePortGenerator)
 from cassandra.marshal import uint8_pack, uint32_pack, int32_pack
 from cassandra.protocol import (write_stringmultimap, write_int, write_string,
@@ -463,6 +463,31 @@ def test_no_req_ids(self, *args):
         holder.return_connection.assert_has_calls(
             [call(max_connection)] * get_holders.call_count)
 
+    def test_heartbeat_future_releases_request_id_when_send_fails(self, *args):
+        connection = Connection(DefaultEndPoint('1.2.3.4'))
+        connection.push = Mock(side_effect=ConnectionException("write failed"))
+        owner = Mock()
+        initial_in_flight = connection.in_flight
+        initial_request_ids = len(connection.request_ids)
+
+        # HostConnection.return_connection releases the heartbeat's in-flight slot.
+        def return_connection(conn):
+            with conn.lock:
+                conn.in_flight -= 1
+
+        owner.return_connection.side_effect = return_connection
+
+        future = HeartbeatFuture(connection, owner)
+
+        with pytest.raises(ConnectionException):
+            future.wait(0)
+
+        owner.return_connection(connection)
+
+        assert connection.in_flight == initial_in_flight
+        assert len(connection.request_ids) == initial_request_ids
+        assert not connection._requests
+
     def test_unexpected_response(self, *args):
         request_id = 999
 

From 84b599c21946b3f832b682d8377bcfbb67037a72 Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Thu, 7 May 2026 01:58:39 -0400
Subject: [PATCH 36/49] cluster: add control-connection query fallback

Add an opt-in control-connection fallback for application queries when the driver cannot populate normal node pools, which happens in deployments that expose the cluster through a non-broadcast IP address such as a TCP proxy or a node public IP. In that mode the driver can still execute queries over the single control connection, but throughput is poor and connection churn increases the chance of request errors. This option is intentionally disabled by default and should not be used in production.

Also propagate keyspace updates on the fallback path so USE keeps the control connection in sync.

Tests:
- tests/unit/test_cluster.py::ClusterTest::test_set_keyspace_for_all_pools_reports_all_errors
- tests/unit/test_response_future.py::ResponseFutureTests::test_control_connection_fallback_updates_connection_keyspace
---
 cassandra/cluster.py                          | 233 +++++++++++++--
 docs/api/cassandra/cluster.rst                |   5 +
 .../integration/cqlengine/model/test_model.py |  10 +-
 tests/integration/standard/conftest.py        |   1 +
 .../test_control_connection_query_fallback.py | 115 +++++++
 tests/unit/test_cluster.py                    |  77 ++++-
 tests/unit/test_response_future.py            | 281 +++++++++++++++++-
 7 files changed, 689 insertions(+), 33 deletions(-)
 create mode 100644 tests/integration/standard/test_control_connection_query_fallback.py

diff --git a/cassandra/cluster.py b/cassandra/cluster.py
index 483843c2a6..1181c6f686 100644
--- a/cassandra/cluster.py
+++ b/cassandra/cluster.py
@@ -28,6 +28,7 @@
 from copy import copy
 from functools import partial, reduce, wraps
 from itertools import groupby, count, chain
+import enum
 import json
 import logging
 from typing import Any, Dict, Optional, Union, Tuple
@@ -514,8 +515,9 @@ def __init__(self, load_balancing_policy=None, retry_policy=None,
 
 class ProfileManager(object):
 
-    def __init__(self):
+    def __init__(self, pools_allowed: bool=True):
         self.profiles = dict()
+        self.pools_allowed = pools_allowed
 
     def _profiles_without_explicit_lbps(self):
         names = (profile_name for
@@ -527,6 +529,8 @@ def _profiles_without_explicit_lbps(self):
         )
 
     def distance(self, host):
+        if not self.pools_allowed:
+            return HostDistance.IGNORED
         distances = set(p.load_balancing_policy.distance(host) for p in self.profiles.values())
         return HostDistance.LOCAL_RACK if HostDistance.LOCAL_RACK in distances else \
             HostDistance.LOCAL if HostDistance.LOCAL in distances else \
@@ -542,10 +546,14 @@ def check_supported(self):
             p.load_balancing_policy.check_supported()
 
     def on_up(self, host):
+        if not self.pools_allowed:
+            return
         for p in self.profiles.values():
             p.load_balancing_policy.on_up(host)
 
     def on_down(self, host):
+        if not self.pools_allowed:
+            return
         for p in self.profiles.values():
             p.load_balancing_policy.on_down(host)
 
@@ -619,6 +627,31 @@ class _ConfigMode(object):
     PROFILES = 2
 
 
+class ControlConnectionQueryFallback(enum.Enum):
+    """
+    Controls how application queries use the control connection when node pools
+    are unavailable.
+
+    ``Disabled`` requires a usable node pool for application queries. If the
+    driver cannot establish one during session startup, it raises
+    :class:`NoHostAvailable`.
+
+    ``Fallback`` still attempts to create node pools, but allows application
+    queries to fall back to the control connection when no usable node pool is
+    available. Session startup is allowed to proceed even if the initial pool
+    attempts all fail.
+
+    ``SkipPoolCreation`` disables node-pool creation for the session and uses
+    the control-connection fallback path for application queries.
+
+    The fallback path is not used for requests targeted to an explicit host.
+    """
+
+    Disabled = "Disabled"
+    Fallback = "Fallback"
+    SkipPoolCreation = "SkipPoolCreation"
+
+
 class Cluster(object):
     """
     The main class to use when interacting with a Cassandra cluster.
@@ -939,6 +972,16 @@ def default_retry_policy(self, policy):
     If set to :const:`None`, there will be no timeout for these queries.
     """
 
+    allow_control_connection_query_fallback: ControlConnectionQueryFallback = ControlConnectionQueryFallback.Disabled
+    """
+    Controls whether application queries may fall back to the control connection.
+
+    ``Disabled`` keeps the old behavior.
+    ``Fallback`` enables control-connection fallback when no usable node pools exist.
+    ``SkipPoolCreation`` skips node-pool creation and uses the control connection fallback path.
+    This fallback is still not used for requests targeted to an explicit host.
+    """
+
     idle_heartbeat_interval = 30
     """
     Interval, in seconds, on which to heartbeat idle connections. This helps
@@ -1225,7 +1268,8 @@ def __init__(self,
                  metadata_request_timeout: Optional[float] = None,
                  column_encryption_policy=None,
                  application_info:Optional[ApplicationInfoBase]=None,
-                 client_routes_config:Optional[ClientRoutesConfig]=None
+                 client_routes_config:Optional[ClientRoutesConfig]=None,
+                 allow_control_connection_query_fallback:Optional[ControlConnectionQueryFallback]=ControlConnectionQueryFallback.Disabled
                  ):
         """
         ``executor_threads`` defines the number of threads in a pool for handling asynchronous tasks such as
@@ -1243,6 +1287,10 @@ def __init__(self,
         if port < 1 or port > 65535:
             raise ValueError("Invalid port number (%s) (1-65535)" % port)
 
+        if not isinstance(allow_control_connection_query_fallback, ControlConnectionQueryFallback):
+            raise TypeError(
+                "allow_control_connection_query_fallback must be a ControlConnectionQueryFallback value")
+
         if connection_class is not None:
             self.connection_class = connection_class
 
@@ -1404,7 +1452,8 @@ def __init__(self,
         else:
             self.timestamp_generator = MonotonicTimestampGenerator()
 
-        self.profile_manager = ProfileManager()
+        self.profile_manager = ProfileManager(
+            pools_allowed=allow_control_connection_query_fallback != ControlConnectionQueryFallback.SkipPoolCreation)
         self.profile_manager.profiles[EXEC_PROFILE_DEFAULT] = ExecutionProfile(
             self.load_balancing_policy,
             self.default_retry_policy,
@@ -1473,6 +1522,7 @@ def __init__(self,
         self.cql_version = cql_version
         self.max_schema_agreement_wait = max_schema_agreement_wait
         self.control_connection_timeout = control_connection_timeout
+        self.allow_control_connection_query_fallback = allow_control_connection_query_fallback
         self.metadata_request_timeout = self.control_connection_timeout if metadata_request_timeout is None else metadata_request_timeout
         self.idle_heartbeat_interval = idle_heartbeat_interval
         self.idle_heartbeat_timeout = idle_heartbeat_timeout
@@ -1815,7 +1865,8 @@ def get_all_pools(self):
         return pools
 
     def is_shard_aware(self):
-        return bool(self.get_all_pools()[0].host.sharding_info)
+        pools = self.get_all_pools()
+        return bool(pools and pools[0].host.sharding_info)
 
     def shard_aware_stats(self):
         if self.is_shard_aware():
@@ -1920,7 +1971,7 @@ def on_up(self, host):
         """
         Intended for internal use only.
         """
-        if self.is_shutdown:
+        if self.is_shutdown or self.allow_control_connection_query_fallback == ControlConnectionQueryFallback.SkipPoolCreation:
             return
 
         log.debug("Waiting to acquire lock for handling up status of node %s", host)
@@ -2028,7 +2079,7 @@ def on_down(self, host, is_host_addition, expect_host_to_be_down=False):
         """
         Intended for internal use only.
         """
-        if self.is_shutdown:
+        if self.is_shutdown or self.allow_control_connection_query_fallback == ControlConnectionQueryFallback.SkipPoolCreation:
             return
 
         with host.lock:
@@ -2633,20 +2684,24 @@ def __init__(self, cluster, hosts, keyspace=None):
 
         # create connection pools in parallel
         self._initial_connect_futures = set()
-        for host in hosts:
-            future = self.add_or_renew_pool(host, is_host_addition=False)
-            if future:
-                self._initial_connect_futures.add(future)
-
-        futures = wait_futures(self._initial_connect_futures, return_when=FIRST_COMPLETED)
-        while futures.not_done and not any(f.result() for f in futures.done):
-            futures = wait_futures(futures.not_done, return_when=FIRST_COMPLETED)
-
-        if not any(f.result() for f in self._initial_connect_futures):
-            msg = "Unable to connect to any servers"
-            if self.keyspace:
-                msg += " using keyspace '%s'" % self.keyspace
-            raise NoHostAvailable(msg, [h.address for h in hosts])
+        fallback_mode = self.cluster.allow_control_connection_query_fallback
+        if fallback_mode is not ControlConnectionQueryFallback.SkipPoolCreation:
+            for host in hosts:
+                future = self.add_or_renew_pool(host, is_host_addition=False)
+                if future:
+                    self._initial_connect_futures.add(future)
+
+            futures = wait_futures(self._initial_connect_futures, return_when=FIRST_COMPLETED)
+            while futures.not_done and not any(f.result() for f in futures.done):
+                futures = wait_futures(futures.not_done, return_when=FIRST_COMPLETED)
+
+            # Only Disabled requires an initial pool to come up.
+            if not any(f.result() for f in self._initial_connect_futures) and \
+                    fallback_mode is ControlConnectionQueryFallback.Disabled:
+                msg = "Unable to connect to any servers"
+                if self.keyspace:
+                    msg += " using keyspace '%s'" % self.keyspace
+                raise NoHostAvailable(msg, [h.address for h in hosts])
 
         self.session_id = uuid.uuid4()
 
@@ -3245,6 +3300,9 @@ def add_or_renew_pool(self, host, is_host_addition):
         """
         For internal use only.
         """
+        if self.cluster.allow_control_connection_query_fallback is ControlConnectionQueryFallback.SkipPoolCreation:
+            return None
+
         distance = self._profile_manager.distance(host)
         if distance == HostDistance.IGNORED:
             return None
@@ -3315,6 +3373,9 @@ def update_created_pools(self):
 
         For internal use only.
         """
+        if self.cluster.allow_control_connection_query_fallback is ControlConnectionQueryFallback.SkipPoolCreation:
+            return set()
+
         futures = set()
         for host in self.cluster.metadata.all_hosts():
             distance = self._profile_manager.distance(host)
@@ -4650,6 +4711,7 @@ class ResponseFuture(object):
     _spec_execution_plan = NoSpeculativeExecutionPlan()
     _continuous_paging_session = None
     _host = None
+    _control_connection_query_attempted = False
     _TABLET_ROUTING_CTYPE = None
 
     _warned_timeout = False
@@ -4670,6 +4732,7 @@ def __init__(self, session, message, query, timeout, metrics=None, prepared_stat
         self._callback_lock = Lock()
         self._start_time = start_time or time.time()
         self._host = host
+        self._control_connection_query_attempted = False
         self._spec_execution_plan = speculative_execution_plan or self._spec_execution_plan
         self._make_query_plan()
         self._event = Event()
@@ -4748,11 +4811,22 @@ def _on_timeout(self, _attempts=0):
                         self._connection.orphaned_threshold_reached = True
 
                 pool.return_connection(self._connection, stream_was_orphaned=True)
+            elif self._connection.is_control_connection:
+                with self._connection.lock:
+                    self._connection.orphaned_request_ids.add(self._req_id)
+                    if len(self._connection.orphaned_request_ids) >= self._connection.orphaned_threshold:
+                        self._connection.orphaned_threshold_reached = True
 
         errors = self._errors
         if not errors:
             if self.is_schema_agreed:
-                key = str(self._current_host.endpoint) if self._current_host else 'no host queried before timeout'
+                if self._current_host is None:
+                    key = 'no host queried before timeout'
+                elif self._connection is not None and self._connection.is_control_connection:
+                    control_host = self.session.cluster.get_control_connection_host()
+                    key = str(control_host.endpoint) if control_host is not None else str(self._connection.endpoint)
+                else:
+                    key = str(self._current_host.endpoint)
                 errors = {key: "Client request timeout. See Session.execute[_async](timeout)"}
             else:
                 connection = self.session.cluster.control_connection._connection
@@ -4810,14 +4884,110 @@ def send_request(self, error_no_hosts=True):
                 self._on_timeout()
                 return True
         if error_no_hosts:
+            if self._fallback_to_control_connection():
+                req_id = self._query_control_connection()
+                if req_id is not None:
+                    self._req_id = req_id
+                    return True
+
             self._set_final_exception(NoHostAvailable(
                 "Unable to complete the operation against any hosts", self._errors))
         return False
 
+    def _has_usable_node_pool(self):
+        try:
+            pools = tuple(self.session._pools.values())
+        except (AttributeError, TypeError):
+            return False
+
+        return any(pool and not pool.is_shutdown for pool in pools)
+
+    def _fallback_to_control_connection(self):
+        fallback_mode = self.session.cluster.allow_control_connection_query_fallback
+        if fallback_mode is ControlConnectionQueryFallback.Disabled:
+            return False
+        if self._host or self._control_connection_query_attempted:
+            return False
+        if fallback_mode is ControlConnectionQueryFallback.SkipPoolCreation:
+            return True
+        return not self._has_usable_node_pool()
+
+    def _borrow_control_connection(self, connection):
+        with connection.lock:
+            if connection.in_flight >= connection.max_request_id:
+                raise NoConnectionsAvailable("All request IDs are currently in use")
+            connection.in_flight += 1
+            return connection.get_request_id()
+
+    def _release_control_connection_request(self, connection, request_id):
+        with connection.lock:
+            connection.in_flight -= 1
+            connection.request_ids.append(request_id)
+            connection._requests.pop(request_id, None)
+
+    def _handle_control_connection_response(self, connection, cb, response):
+        with connection.lock:
+            connection.in_flight -= 1
+        cb(response)
+
+    def _query_control_connection(self, message=None, cb=None, connection=None, host=None):
+        self._control_connection_query_attempted = True
+
+        if message is None:
+            message = self.message
+
+        if connection is None:
+            control_connection = self.session.cluster.control_connection
+            connection = control_connection._connection if control_connection else None
+        if not connection:
+            self._errors['control connection'] = ConnectionException("Control connection is not connected")
+            return None
+
+        if host is None:
+            host = self.session.cluster.get_control_connection_host() or connection.endpoint
+        self._current_host = host
+
+        request_id = None
+        request_sent = False
+        try:
+            request_id = self._borrow_control_connection(connection)
+            self._connection = connection
+            result_meta = self.prepared_statement.result_metadata if self.prepared_statement else []
+            if cb is None:
+                cb = partial(self._set_result, host, connection, None)
+            cb = partial(self._handle_control_connection_response, connection, cb)
+
+            log.debug("No usable node pools; falling back to control connection for host %s", host)
+            self.request_encoded_size = connection.send_msg(message, request_id, cb=cb,
+                                                            encoder=self._protocol_handler.encode_message,
+                                                            decoder=self._protocol_handler.decode_message,
+                                                            result_metadata=result_meta)
+            request_sent = True
+            self.attempted_hosts.append(host)
+            return request_id
+        except NoConnectionsAvailable as exc:
+            log.debug("Control connection is at capacity")
+            self._errors[host] = exc
+        except ConnectionBusy as exc:
+            log.debug("Control connection is busy")
+            self._errors[host] = exc
+        except Exception as exc:
+            log.debug("Error querying control connection", exc_info=True)
+            self._errors[host] = exc
+            if self._metrics is not None:
+                self._metrics.on_connection_error()
+        finally:
+            if request_id is not None and not request_sent:
+                self._release_control_connection_request(connection, request_id)
+
+        return None
+
     def _query(self, host, message=None, cb=None):
         if message is None:
             message = self.message
 
+        self._control_connection_query_attempted = False
+
         pool = self.session._pools.get(host)
         if not pool:
             self._errors[host] = ConnectionException("Host has been marked down or removed")
@@ -4928,12 +5098,17 @@ def start_fetching_next_page(self):
         self._event.clear()
         self._final_result = _NOT_SET
         self._final_exception = None
+        self._control_connection_query_attempted = False
         self._start_timer()
         self.send_request()
 
     def _reprepare(self, prepare_message, host, connection, pool):
         cb = partial(self.session.submit, self._execute_after_prepare, host, connection, pool)
-        request_id = self._query(host, prepare_message, cb=cb)
+        if pool is None and connection is not None and connection.is_control_connection:
+            request_id = self._query_control_connection(prepare_message, cb=cb,
+                                                        connection=connection, host=host)
+        else:
+            request_id = self._query(host, prepare_message, cb=cb)
         if request_id is None:
             # try to submit the original prepared statement on some other host
             self.send_request()
@@ -4972,6 +5147,8 @@ def _set_result(self, host, connection, pool, response):
             if isinstance(response, ResultMessage):
                 if response.kind == RESULT_KIND_SET_KEYSPACE:
                     session = getattr(self, 'session', None)
+                    if connection is not None:
+                        connection.keyspace = response.new_keyspace
                     # since we're running on the event loop thread, we need to
                     # use a non-blocking method for setting the keyspace on
                     # all connections in this session, otherwise the event
@@ -5148,10 +5325,13 @@ def _execute_after_prepare(self, host, connection, pool, response):
                     new_metadata_id = response.result_metadata_id
                     if new_metadata_id is not None:
                         self.prepared_statement.result_metadata_id = new_metadata_id
-
+                
                 # use self._query to re-use the same host and
                 # at the same time properly borrow the connection
-                request_id = self._query(host)
+                if pool is None and connection is not None and connection.is_control_connection:
+                    request_id = self._query_control_connection(connection=connection, host=host)
+                else:
+                    request_id = self._query(host)
                 if request_id is None:
                     # this host errored out, move on to the next
                     self.send_request()
@@ -5264,6 +5444,11 @@ def _retry_task(self, reuse_connection, host):
             # to retry the operation
             return
 
+        if self._control_connection_query_attempted:
+            self._control_connection_query_attempted = False
+            self.send_request()
+            return
+
         if reuse_connection and self._query(host) is not None:
             return
 
diff --git a/docs/api/cassandra/cluster.rst b/docs/api/cassandra/cluster.rst
index de8518d271..44b7b63f67 100644
--- a/docs/api/cassandra/cluster.rst
+++ b/docs/api/cassandra/cluster.rst
@@ -48,6 +48,8 @@ Clusters and Sessions
 
    .. autoattribute:: control_connection_timeout
 
+   .. autoattribute:: allow_control_connection_query_fallback
+
    .. autoattribute:: idle_heartbeat_interval
 
    .. autoattribute:: idle_heartbeat_timeout
@@ -106,6 +108,9 @@ Clusters and Sessions
 
    .. automethod:: set_meta_refresh_enabled
 
+.. autoclass:: ControlConnectionQueryFallback
+   :members:
+
 .. autoclass:: ExecutionProfile (load_balancing_policy=<object object>, retry_policy=None, consistency_level=ConsistencyLevel.LOCAL_ONE, serial_consistency_level=None, request_timeout=10.0, row_factory=<function named_tuple_factory>, speculative_execution_policy=None)
    :members:
    :exclude-members: consistency_level
diff --git a/tests/integration/cqlengine/model/test_model.py b/tests/integration/cqlengine/model/test_model.py
index cafe6ae9c9..98d71993fd 100644
--- a/tests/integration/cqlengine/model/test_model.py
+++ b/tests/integration/cqlengine/model/test_model.py
@@ -259,10 +259,8 @@ class SensitiveModel(Model):
             rows[-1]
             rows[-1:]
 
-            # ignore DeprecationWarning('The loop argument is deprecated since Python 3.8, and scheduled for removal in Python 3.10.')
-            relevant_warnings = [warn for warn in w if "The loop argument is deprecated" not in str(warn.message)]
+            warning_messages = [str(warn.message) for warn in w]
 
-            assert "__table_name_case_sensitive__ will be removed in 4.0." in str(relevant_warnings[0].message)
-            assert "__table_name_case_sensitive__ will be removed in 4.0." in str(relevant_warnings[1].message)
-            assert "ModelQuerySet indexing with negative indices support will be removed in 4.0." in str(relevant_warnings[2].message)
-            assert "ModelQuerySet slicing with negative indices support will be removed in 4.0." in str(relevant_warnings[3].message)
+            assert sum("__table_name_case_sensitive__ will be removed in 4.0." in message for message in warning_messages) == 2
+            assert sum("ModelQuerySet indexing with negative indices support will be removed in 4.0." in message for message in warning_messages) == 1
+            assert sum("ModelQuerySet slicing with negative indices support will be removed in 4.0." in message for message in warning_messages) == 1
diff --git a/tests/integration/standard/conftest.py b/tests/integration/standard/conftest.py
index 3adaf371b0..9934cfcbbb 100644
--- a/tests/integration/standard/conftest.py
+++ b/tests/integration/standard/conftest.py
@@ -37,6 +37,7 @@
     "test_ip_change": 4,
     "test_authentication": 4,
     "test_authentication_misconfiguration": 4,
+    "test_control_connection_query_fallback": 4,
     "test_custom_cluster": 4,
     "test_query": 4,
     # Group 5: tablets (destructive — decommissions a node)
diff --git a/tests/integration/standard/test_control_connection_query_fallback.py b/tests/integration/standard/test_control_connection_query_fallback.py
new file mode 100644
index 0000000000..e64763a72c
--- /dev/null
+++ b/tests/integration/standard/test_control_connection_query_fallback.py
@@ -0,0 +1,115 @@
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import pytest
+
+from cassandra.cluster import ControlConnectionQueryFallback, NoHostAvailable
+
+from tests.integration import USE_CASS_EXTERNAL, TestCluster, local, remove_cluster, use_cluster
+
+
+_CLUSTER_NAME = "control_connection_query_fallback"
+_UNREACHABLE_BROADCAST_RPC_ADDRESS = "127.255.255.1"
+
+
+def setup_module():
+    if USE_CASS_EXTERNAL:
+        return
+
+    remove_cluster()
+
+    ccm_cluster = use_cluster(_CLUSTER_NAME, [1], start=False)
+    ccm_cluster.nodes["node1"].set_configuration_options(values={
+        "broadcast_rpc_address": _UNREACHABLE_BROADCAST_RPC_ADDRESS,
+    })
+    ccm_cluster.start(wait_for_binary_proto=True, wait_other_notice=True)
+
+
+def teardown_module():
+    if USE_CASS_EXTERNAL:
+        return
+
+    remove_cluster()
+
+
+@local
+class ControlConnectionQueryFallbackIntegrationTests(unittest.TestCase):
+
+    def setUp(self):
+        self.cluster = None
+
+    def tearDown(self):
+        if self.cluster is not None:
+            self.cluster.shutdown()
+
+    def _assert_unreachable_broadcast_rpc_metadata(self):
+        hosts = self.cluster.metadata.all_hosts()
+        assert len(hosts) == 1
+
+        host = hosts[0]
+        assert host.broadcast_rpc_address == _UNREACHABLE_BROADCAST_RPC_ADDRESS
+        assert host.endpoint.address == _UNREACHABLE_BROADCAST_RPC_ADDRESS
+        return host
+
+    def test_disabled_raises_when_broadcast_rpc_address_is_unreachable(self):
+        self.cluster = TestCluster(
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.Disabled,
+            connect_timeout=1,
+            monitor_reporting_enabled=False,
+        )
+
+        with pytest.raises(NoHostAvailable):
+            self.cluster.connect()
+
+        self._assert_unreachable_broadcast_rpc_metadata()
+        assert self.cluster.control_connection._connection is not None
+        assert self.cluster.get_all_pools() == []
+
+    def test_fallback_executes_queries_when_broadcast_rpc_address_is_unreachable(self):
+        self.cluster = TestCluster(
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.Fallback,
+            connect_timeout=1,
+            monitor_reporting_enabled=False,
+        )
+
+        session = self.cluster.connect()
+
+        self._assert_unreachable_broadcast_rpc_metadata()
+        assert session._initial_connect_futures
+        assert list(session.get_pools()) == []
+
+        row = session.execute(
+            "SELECT release_version, rpc_address FROM system.local WHERE key='local'").one()
+        assert str(row.rpc_address) == _UNREACHABLE_BROADCAST_RPC_ADDRESS
+        assert row.release_version
+
+    def test_no_node_pool_fallback_executes_queries_without_creating_pools(self):
+        self.cluster = TestCluster(
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.SkipPoolCreation,
+            connect_timeout=1,
+            monitor_reporting_enabled=False,
+        )
+
+        session = self.cluster.connect()
+
+        self._assert_unreachable_broadcast_rpc_metadata()
+        assert session._initial_connect_futures == set()
+        assert list(session.get_pools()) == []
+
+        row = session.execute(
+            "SELECT release_version, rpc_address FROM system.local WHERE key='local'").one()
+        assert str(row.rpc_address) == _UNREACHABLE_BROADCAST_RPC_ADDRESS
+        assert row.release_version
diff --git a/tests/unit/test_cluster.py b/tests/unit/test_cluster.py
index b6f2da5372..3d55bc1860 100644
--- a/tests/unit/test_cluster.py
+++ b/tests/unit/test_cluster.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 import unittest
 
+from concurrent.futures import Future
 import logging
 import socket
 from types import SimpleNamespace
@@ -22,9 +23,9 @@
 
 from cassandra import ConsistencyLevel, DriverException, Timeout, Unavailable, RequestExecutionException, ReadTimeout, WriteTimeout, CoordinationFailure, ReadFailure, WriteFailure, FunctionFailure, AlreadyExists,\
     InvalidRequest, Unauthorized, AuthenticationFailed, OperationTimedOut, UnsupportedOperation, RequestValidationException, ConfigurationException, ProtocolVersion
-from cassandra.cluster import _Scheduler, Session, Cluster, ResultSet, SchemaAgreementScope, default_lbp_factory, \
+from cassandra.cluster import _Scheduler, Session, Cluster, ResultSet, SchemaAgreementScope, ControlConnectionQueryFallback, default_lbp_factory, \
     ExecutionProfile, _ConfigMode, EXEC_PROFILE_DEFAULT
-from cassandra.connection import ConnectionBusy
+from cassandra.connection import ConnectionBusy, ConnectionException
 from cassandra.pool import Host
 from cassandra.policies import HostDistance, RetryPolicy, RoundRobinPolicy, DowngradingConsistencyRetryPolicy, SimpleConvictionPolicy
 from cassandra.query import SimpleStatement, named_tuple_factory, tuple_factory
@@ -186,6 +187,52 @@ def test_port_range(self):
             with pytest.raises(ValueError):
                 cluster = Cluster(contact_points=['127.0.0.1'], port=invalid_port)
 
+    def test_control_connection_query_fallback_modes(self):
+        assert Cluster().allow_control_connection_query_fallback is ControlConnectionQueryFallback.Disabled
+        with pytest.raises(TypeError):
+            Cluster(allow_control_connection_query_fallback=False)
+        with pytest.raises(TypeError):
+            Cluster(allow_control_connection_query_fallback=True)
+        assert (
+            Cluster(allow_control_connection_query_fallback=ControlConnectionQueryFallback.Fallback)
+            .allow_control_connection_query_fallback
+            is ControlConnectionQueryFallback.Fallback
+        )
+        assert Cluster(
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.SkipPoolCreation
+        ).allow_control_connection_query_fallback is ControlConnectionQueryFallback.SkipPoolCreation
+
+    def test_control_connection_query_fallback_no_node_pool_mode_skips_pool_creation(self):
+        cluster = Cluster(
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.SkipPoolCreation,
+            monitor_reporting_enabled=False,
+        )
+        host = Host("127.0.0.1", SimpleConvictionPolicy, host_id=uuid.uuid4())
+
+        with patch.object(Session, "add_or_renew_pool") as mocked_add_or_renew_pool:
+            session = Session(cluster, [host])
+
+        mocked_add_or_renew_pool.assert_not_called()
+        assert session._initial_connect_futures == set()
+        assert session._pools == {}
+        assert session.update_created_pools() == set()
+
+    def test_control_connection_query_fallback_fallback_tolerates_empty_initial_pools(self):
+        cluster = Cluster(
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.Fallback,
+            monitor_reporting_enabled=False,
+        )
+        host = Host("127.0.0.1", SimpleConvictionPolicy, host_id=uuid.uuid4())
+        future = Future()
+        future.set_result(False)
+
+        with patch.object(Session, "add_or_renew_pool", return_value=future) as mocked_add_or_renew_pool:
+            session = Session(cluster, [host])
+
+        mocked_add_or_renew_pool.assert_called_once_with(host, is_host_addition=False)
+        assert session._initial_connect_futures == {future}
+        assert session._pools == {}
+
     def test_compression_autodisabled_without_libraries(self):
         with patch.dict('cassandra.cluster.locally_supported_compressions', {}, clear=True):
             with patch('cassandra.cluster.log') as patched_logger:
@@ -551,6 +598,32 @@ def test_wait_for_schema_agreement_rejects_unknown_scope(self, *_):
         with pytest.raises(ValueError):
             session.wait_for_schema_agreement(wait_time=1, scope='planet')
 
+    @mock_session_pools
+    def test_set_keyspace_for_all_pools_reports_all_errors(self, *_):
+        cluster = Cluster()
+        session = Session(
+            cluster,
+            [Host("127.0.0.1", SimpleConvictionPolicy, host_id=uuid.uuid4())],
+        )
+
+        pool1 = Mock(host='host1')
+        pool2 = Mock(host='host2')
+        keyspace_error = ConnectionException("boom")
+
+        pool1._set_keyspace_for_all_conns.side_effect = (
+            lambda keyspace, callback: callback(pool1, [keyspace_error])
+        )
+        pool2._set_keyspace_for_all_conns.side_effect = (
+            lambda keyspace, callback: callback(pool2, [])
+        )
+        session._pools = {'host1': pool1, 'host2': pool2}
+
+        callback = Mock()
+        session._set_keyspace_for_all_pools('ks', callback)
+
+        callback.assert_called_once()
+        assert callback.call_args.args[0] == {'host1': [keyspace_error]}
+
 class ProtocolVersionTests(unittest.TestCase):
 
     def test_protocol_downgrade_test(self):
diff --git a/tests/unit/test_response_future.py b/tests/unit/test_response_future.py
index dd7fa75045..9673b0d634 100644
--- a/tests/unit/test_response_future.py
+++ b/tests/unit/test_response_future.py
@@ -19,7 +19,7 @@
 from unittest.mock import Mock, MagicMock, ANY
 
 from cassandra import ConsistencyLevel, Unavailable, SchemaTargetType, SchemaChangeType, OperationTimedOut
-from cassandra.cluster import Session, ResponseFuture, NoHostAvailable, ProtocolVersion
+from cassandra.cluster import Session, ResponseFuture, NoHostAvailable, ProtocolVersion, ControlConnectionQueryFallback
 from cassandra.connection import Connection, ConnectionException
 from cassandra.protocol import (ReadTimeoutErrorMessage, WriteTimeoutErrorMessage,
                                 UnavailableErrorMessage, ResultMessage, QueryMessage,
@@ -41,6 +41,7 @@ def make_basic_session(self):
         s = Mock(spec=Session)
         s.row_factory = lambda col_names, rows: [(col_names, rows)]
         s.cluster.control_connection._tablets_routing_v1 = False
+        s.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Disabled
         return s
 
     def make_pool(self):
@@ -49,6 +50,22 @@ def make_pool(self):
         pool.borrow_connection.return_value = [Mock(), Mock()]
         return pool
 
+    def make_control_connection(self):
+        connection = Mock(spec=Connection)
+        connection.endpoint = 'control-host'
+        connection.lock = RLock()
+        connection.in_flight = 0
+        connection.max_request_id = 100
+        connection.request_ids = deque()
+        connection._requests = {}
+        connection.orphaned_request_ids = set()
+        connection.orphaned_threshold = 75
+        connection.orphaned_threshold_reached = False
+        connection.is_control_connection = True
+        connection.get_request_id.return_value = 7
+        connection.send_msg.return_value = 128
+        return connection
+
     def make_session(self):
         session = self.make_basic_session()
         session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1', 'ip2']
@@ -391,6 +408,268 @@ def test_all_pools_shutdown(self):
         with pytest.raises(NoHostAvailable):
             rf.result()
 
+    def test_control_connection_fallback_disabled_by_default(self):
+        session = self.make_basic_session()
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        session._pools = {}
+        connection = self.make_control_connection()
+        session.cluster.control_connection._connection = connection
+
+        rf = self.make_response_future(session)
+        rf.send_request()
+
+        connection.send_msg.assert_not_called()
+        with pytest.raises(NoHostAvailable):
+            rf.result()
+
+    def test_control_connection_fallback_updates_connection_keyspace(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        session._pools = {}
+
+        def set_keyspace_for_all_pools(keyspace, callback):
+            session.keyspace = keyspace
+            callback({})
+
+        session._set_keyspace_for_all_pools.side_effect = set_keyspace_for_all_pools
+
+        connection = self.make_control_connection()
+        connection.keyspace = 'oldks'
+        session.cluster.control_connection._connection = connection
+        control_host = Mock(endpoint=connection.endpoint)
+        session.cluster.get_control_connection_host.return_value = control_host
+
+        rf = self.make_response_future(session)
+        assert rf.send_request()
+
+        result = Mock(spec=ResultMessage, kind=RESULT_KIND_SET_KEYSPACE, new_keyspace='newks')
+        connection.send_msg.call_args[1]['cb'](result)
+
+        assert connection.keyspace == 'newks'
+        assert session.keyspace == 'newks'
+        assert rf.result().current_rows == []
+
+    def test_control_connection_fallback_when_no_usable_pools(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.SkipPoolCreation
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1', 'ip2']
+        session._pools = {}
+        connection = self.make_control_connection()
+        session.cluster.control_connection._connection = connection
+        control_host = Mock(endpoint=connection.endpoint)
+        session.cluster.get_control_connection_host.return_value = control_host
+
+        rf = self.make_response_future(session)
+        assert rf.send_request()
+
+        connection.send_msg.assert_called_once_with(
+            rf.message, 7, cb=ANY, encoder=ProtocolHandler.encode_message,
+            decoder=ProtocolHandler.decode_message, result_metadata=[])
+        assert connection.in_flight == 1
+        assert rf.attempted_hosts == [control_host]
+
+        cb = connection.send_msg.call_args[1]['cb']
+        expected_result = (object(), object())
+        cb(self.make_mock_response(expected_result[0], expected_result[1]))
+
+        assert connection.in_flight == 0
+        assert rf.result()[0] == expected_result
+
+    def test_control_connection_fallback_retries_after_server_error(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        session._pools = {}
+        connection = self.make_control_connection()
+        connection.get_request_id.side_effect = [7, 8]
+        session.cluster.control_connection._connection = connection
+        control_host = Mock(endpoint=connection.endpoint)
+        session.cluster.get_control_connection_host.return_value = control_host
+
+        rf = self.make_response_future(session)
+        assert rf.send_request()
+
+        first_response = Mock(spec=ServerError, info={})
+        first_response.summary = 'boom'
+        first_response.to_exception.return_value = first_response
+        connection.send_msg.call_args[1]['cb'](first_response)
+
+        rf.session.cluster.scheduler.schedule.assert_called_once_with(ANY, rf._retry_task, False, control_host)
+
+        # The retry decision must come from the future state, not the live connection reference.
+        rf._connection = Mock(is_control_connection=False)
+
+        rf._retry_task(False, control_host)
+
+        assert connection.send_msg.call_count == 2
+        assert connection.send_msg.call_args_list[1][0][0] is rf.message
+        assert connection.send_msg.call_args_list[1][0][1] == 8
+        assert rf.attempted_hosts == [control_host, control_host]
+
+        expected_result = (object(), object())
+        connection.send_msg.call_args_list[1][1]['cb'](
+            self.make_mock_response(expected_result[0], expected_result[1]))
+
+        assert connection.in_flight == 0
+        assert rf.result()[0] == expected_result
+
+    def test_control_connection_fallback_fetches_next_page(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        session._pools = {}
+        connection = self.make_control_connection()
+        connection.get_request_id.side_effect = [7, 8]
+        session.cluster.control_connection._connection = connection
+        control_host = Mock(endpoint=connection.endpoint)
+        session.cluster.get_control_connection_host.return_value = control_host
+
+        rf = self.make_response_future(session)
+        assert rf.send_request()
+
+        first_response = self.make_mock_response(['col'], [(1,)])
+        first_response.paging_state = b'next-page'
+        connection.send_msg.call_args[1]['cb'](first_response)
+
+        assert rf.result().current_rows == [(['col'], [(1,)])]
+        assert rf.has_more_pages
+
+        rf.start_fetching_next_page()
+
+        assert connection.send_msg.call_count == 2
+        assert connection.send_msg.call_args_list[1][0][0] is rf.message
+        assert connection.send_msg.call_args_list[1][0][1] == 8
+        assert rf.message.paging_state == b'next-page'
+
+        second_response = self.make_mock_response(['col'], [(2,)])
+        connection.send_msg.call_args_list[1][1]['cb'](second_response)
+
+        assert connection.in_flight == 0
+        assert rf.result().current_rows == [(['col'], [(2,)])]
+
+    def test_control_connection_fallback_reprepares_prepared_statement(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster.protocol_version = ProtocolVersion.V4
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        session._pools = {}
+        session.submit.side_effect = lambda fn, *args, **kwargs: fn(*args, **kwargs)
+
+        query_id = b'a' * 16
+        prepared_statement = Mock(
+            query_id=query_id,
+            query_string="SELECT * FROM foobar",
+            keyspace="FooKeyspace",
+            result_metadata=[],
+            result_metadata_id=None)
+        session.cluster._prepared_statements = {query_id: prepared_statement}
+
+        connection = self.make_control_connection()
+        connection.keyspace = "FooKeyspace"
+        connection.get_request_id.side_effect = [7, 8, 9]
+        session.cluster.control_connection._connection = connection
+        control_host = Mock(endpoint=connection.endpoint)
+        session.cluster.get_control_connection_host.return_value = control_host
+
+        rf = self.make_response_future(session)
+        rf.prepared_statement = prepared_statement
+        assert rf.send_request()
+
+        missing = Mock(spec=PreparedQueryNotFound, info=query_id)
+        connection.send_msg.call_args_list[0][1]['cb'](missing)
+
+        assert connection.send_msg.call_count == 2
+        prepare_message = connection.send_msg.call_args_list[1][0][0]
+        assert isinstance(prepare_message, PrepareMessage)
+        assert prepare_message.query == "SELECT * FROM foobar"
+        assert connection.send_msg.call_args_list[1][0][1] == 8
+
+        prepared_response = Mock(
+            spec=ResultMessage,
+            kind=RESULT_KIND_PREPARED,
+            query_id=query_id,
+            column_metadata=[],
+            result_metadata_id=None)
+        connection.send_msg.call_args_list[1][1]['cb'](prepared_response)
+
+        assert connection.send_msg.call_count == 3
+        assert connection.send_msg.call_args_list[2][0][0] is rf.message
+        assert connection.send_msg.call_args_list[2][0][1] == 9
+
+        expected_result = (['col'], [(1,)])
+        connection.send_msg.call_args_list[2][1]['cb'](
+            self.make_mock_response(expected_result[0], expected_result[1]))
+
+        assert connection.in_flight == 0
+        assert rf.result()[0] == expected_result
+
+    def test_control_connection_fallback_not_used_when_pool_can_serve(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        pool = Mock(is_shutdown=False)
+        pool.borrow_connection.side_effect = NoConnectionsAvailable()
+        session._pools = {'ip1': pool}
+        connection = self.make_control_connection()
+        session.cluster.control_connection._connection = connection
+
+        rf = self.make_response_future(session)
+        rf.send_request()
+
+        connection.send_msg.assert_not_called()
+        with pytest.raises(NoHostAvailable):
+            rf.result()
+
+    def test_control_connection_fallback_orphans_stream_on_timeout(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1']
+        session._pools = {}
+        connection = self.make_control_connection()
+        session.cluster.control_connection._connection = connection
+
+        def send_msg(message, request_id, cb, **kwargs):
+            connection._requests[request_id] = (cb, kwargs.get('decoder'), kwargs.get('result_metadata'))
+            return 128
+
+        connection.send_msg.side_effect = send_msg
+
+        rf = self.make_response_future(session)
+        rf.send_request()
+        rf._on_timeout()
+
+        assert 7 in connection.orphaned_request_ids
+        assert connection.in_flight == 1
+        with pytest.raises(OperationTimedOut):
+            rf.result()
+
+    def test_control_connection_fallback_timeout_without_metadata_host_uses_connection_endpoint(self):
+        session = self.make_basic_session()
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.Fallback
+        session.cluster._default_load_balancing_policy.make_query_plan.return_value = []
+        session._pools = {}
+        session.cluster.get_control_connection_host.return_value = None
+        connection = self.make_control_connection()
+        session.cluster.control_connection._connection = connection
+
+        def send_msg(message, request_id, cb, **kwargs):
+            connection._requests[request_id] = (cb, kwargs.get('decoder'), kwargs.get('result_metadata'))
+            return 128
+
+        connection.send_msg.side_effect = send_msg
+
+        rf = self.make_response_future(session)
+        assert rf.send_request()
+        rf._on_timeout()
+
+        with pytest.raises(OperationTimedOut) as exc_info:
+            rf.result()
+
+        assert exc_info.value.errors == {
+            'control-host': 'Client request timeout. See Session.execute[_async](timeout)'
+        }
+
     def test_first_pool_shutdown(self):
         session = self.make_basic_session()
         session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1', 'ip2']

From 442f1edd7412049d438b021b1d83e7a5e2ce6f17 Mon Sep 17 00:00:00 2001
From: Dmitry Kropachev <dmitry.kropachev@gmail.com>
Date: Sun, 10 May 2026 00:55:32 -0400
Subject: [PATCH 37/49] Release 3.29.10: changelog, version and documentation

---
 CHANGELOG.rst         | 25 +++++++++++++++++++++++++
 cassandra/__init__.py |  2 +-
 docs/conf.py          |  4 ++--
 docs/installation.rst |  4 ++--
 4 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 3ae00a7ee8..39a8aca069 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,3 +1,28 @@
+3.29.10
+=======
+May 10, 2026
+
+Features
+--------
+* Fast-path ``lookup_casstype()`` for simple type names
+* Add ``Session.wait_for_schema_agreement``
+
+Bug Fixes
+---------
+* Fix CQL injection in ``Connection.set_keyspace_blocking`` and ``Connection.set_keyspace_async``
+* Fix libev shutdown crashes by correcting atexit registration
+* Handle ``None`` ``control_connection_timeout`` in ``wait_for_schema_agreement``
+* Clean up failed heartbeat sends
+* Fix ``ExponentialBackoffRetryPolicy.__init__`` super() call
+* Correct ``clustering_key`` to ``clustering`` in column kind filter
+* Fix inverted cooldown check in ``_get_shard_aware_endpoint``
+
+Others
+------
+* Deprecate ``ControlConnection.wait_for_schema_agreement``
+* Add timeout and in-flight observability to ``OperationTimedOut``
+* Drop per-query connection log
+
 3.29.9
 ======
 March 18, 2026
diff --git a/cassandra/__init__.py b/cassandra/__init__.py
index 46de7daaf0..1286f20e9b 100644
--- a/cassandra/__init__.py
+++ b/cassandra/__init__.py
@@ -23,7 +23,7 @@ def emit(self, record):
 
 logging.getLogger('cassandra').addHandler(NullHandler())
 
-__version_info__ = (3, 29, 9)
+__version_info__ = (3, 29, 10)
 __version__ = '.'.join(map(str, __version_info__))
 
 
diff --git a/docs/conf.py b/docs/conf.py
index 87a38c6add..34ef31ccae 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -29,11 +29,11 @@
     '3.29.6-scylla',
     '3.29.7-scylla',
     '3.29.8-scylla',
-    '3.29.9-scylla',
+    '3.29.10-scylla',
 ]
 BRANCHES = ['master']
 # Set the latest version.
-LATEST_VERSION = '3.29.9-scylla'
+LATEST_VERSION = '3.29.10-scylla'
 # Set which versions are not released yet.
 UNSTABLE_VERSIONS = ['master']
 # Set which versions are deprecated
diff --git a/docs/installation.rst b/docs/installation.rst
index fbb9ac4043..6a4b38ea80 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -26,7 +26,7 @@ To check if the installation was successful, you can run::
 
     python -c 'import cassandra; print(cassandra.__version__)'
 
-It should print something like "3.29.9".
+It should print something like "3.29.10".
 
 (*Optional*) Compression Support
 --------------------------------
@@ -190,7 +190,7 @@ through `Homebrew <http://brew.sh/>`_. For example, on Mac OS X::
 
     $ brew install libev
 
-The libev extension can now be built for Windows as of Python driver version 3.29.9.  You can
+The libev extension can now be built for Windows as of Python driver version 3.29.10.  You can
 install libev using any Windows package manager.  For example, to install using `vcpkg <https://vcpkg.io>`_:
 
     $ vcpkg install libev

From 69bb8efc9a3742de4de3b4fac61086b5b310db08 Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Wed, 22 Apr 2026 10:43:51 +0200
Subject: [PATCH 38/49] tests: replace SimpleStrategy with
 NetworkTopologyStrategy

Replace SimpleStrategy with NetworkTopologyStrategy across integration
tests to align with ScyllaDB's tablet-based replication defaults.

In the tablets test module, skip default keyspace creation
(set_keyspace=False) to avoid RF=3 keyspaces that block node
decommission when all nodes already hold replicas.
---
 tests/integration/__init__.py                 |  8 ++---
 .../column_encryption/test_policies.py        |  2 +-
 .../standard/test_client_routes.py            |  2 +-
 tests/integration/standard/test_cluster.py    |  4 +--
 ..._concurrent_schema_change_and_node_kill.py |  2 +-
 .../standard/test_control_connection.py       |  2 +-
 .../standard/test_custom_protocol_handler.py  | 11 ++++---
 .../standard/test_cython_protocol_handlers.py |  4 +--
 tests/integration/standard/test_metadata.py   | 32 ++++++++++++-------
 tests/integration/standard/test_policies.py   |  2 +-
 .../standard/test_prepared_statements.py      |  4 +--
 tests/integration/standard/test_query.py      |  4 +--
 .../standard/test_rate_limit_exceeded.py      |  2 +-
 .../integration/standard/test_shard_aware.py  |  4 ++-
 tests/integration/standard/test_tablets.py    |  2 +-
 tests/integration/standard/test_udts.py       | 10 +++---
 .../integration/standard/test_use_keyspace.py |  2 +-
 17 files changed, 54 insertions(+), 43 deletions(-)

diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
index 6a809bded4..7d4d47c9a7 100644
--- a/tests/integration/__init__.py
+++ b/tests/integration/__init__.py
@@ -651,17 +651,17 @@ def setup_keyspace(ipformat=None, protocol_version=None, port=9042):
 
         ddl = '''
             CREATE KEYSPACE test3rf
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}'''
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '3'}'''
         execute_with_long_wait_retry(session, ddl)
 
         ddl = '''
             CREATE KEYSPACE test2rf
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '2'}'''
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '2'}'''
         execute_with_long_wait_retry(session, ddl)
 
         ddl = '''
             CREATE KEYSPACE test1rf
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}'''
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}'''
         execute_with_long_wait_retry(session, ddl)
 
         ddl_3f = '''
@@ -774,7 +774,7 @@ def drop_keyspace(cls):
 
     @classmethod
     def create_keyspace(cls, rf):
-        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.ks_name, rf)
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}".format(cls.ks_name, rf)
         execute_with_long_wait_retry(cls.session, ddl)
 
     @classmethod
diff --git a/tests/integration/standard/column_encryption/test_policies.py b/tests/integration/standard/column_encryption/test_policies.py
index 9a1d186895..4b12fa135a 100644
--- a/tests/integration/standard/column_encryption/test_policies.py
+++ b/tests/integration/standard/column_encryption/test_policies.py
@@ -30,7 +30,7 @@ class ColumnEncryptionPolicyTest(unittest.TestCase):
 
     def _recreate_keyspace(self, session):
         session.execute("drop keyspace if exists foo")
-        session.execute("CREATE KEYSPACE foo WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}")
+        session.execute("CREATE KEYSPACE foo WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}")
         session.execute("CREATE TABLE foo.bar(encrypted blob, unencrypted int, primary key(unencrypted))")
 
     def _create_policy(self, key, iv = None):
diff --git a/tests/integration/standard/test_client_routes.py b/tests/integration/standard/test_client_routes.py
index 5a20421276..290d1741f7 100644
--- a/tests/integration/standard/test_client_routes.py
+++ b/tests/integration/standard/test_client_routes.py
@@ -741,7 +741,7 @@ def test_queries_succeed_through_proxy(self):
             session = cluster.connect()
             session.execute(
                 "CREATE KEYSPACE IF NOT EXISTS test_cr_ks "
-                "WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3}"
+                "WITH replication = {'class':'NetworkTopologyStrategy', 'replication_factor': 3}"
             )
             session.execute(
                 "CREATE TABLE IF NOT EXISTS test_cr_ks.t (k int PRIMARY KEY, v text)"
diff --git a/tests/integration/standard/test_cluster.py b/tests/integration/standard/test_cluster.py
index 08b823d716..15e525f43c 100644
--- a/tests/integration/standard/test_cluster.py
+++ b/tests/integration/standard/test_cluster.py
@@ -180,7 +180,7 @@ def test_basic(self):
         result = execute_until_pass(session,
             """
             CREATE KEYSPACE clustertests
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
             """)
         assert not result
 
@@ -1506,7 +1506,7 @@ def test_prepare_on_ignored_hosts(self):
         hosts = cluster.metadata.all_hosts()
         session.execute("CREATE KEYSPACE clustertests "
                         "WITH replication = "
-                        "{'class': 'SimpleStrategy', 'replication_factor': '1'}")
+                        "{'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}")
         session.execute("CREATE TABLE clustertests.tab (a text, PRIMARY KEY (a))")
         # assign to an unused variable so cluster._prepared_statements retains
         # reference
diff --git a/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py b/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py
index 910dcaa9fe..9a9a3d325f 100644
--- a/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py
+++ b/tests/integration/standard/test_concurrent_schema_change_and_node_kill.py
@@ -27,7 +27,7 @@ def test_schema_change_after_node_kill(self):
             "DROP KEYSPACE IF EXISTS ks_deadlock;")
         self.session.execute(
             "CREATE KEYSPACE IF NOT EXISTS ks_deadlock "
-            "WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '2' };")
+            "WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '2' };")
         self.session.set_keyspace('ks_deadlock')
         self.session.execute("CREATE TABLE IF NOT EXISTS some_table(k int, c int, v int, PRIMARY KEY (k, v));")
         self.session.execute("INSERT INTO some_table (k, c, v) VALUES (1, 2, 3);")
diff --git a/tests/integration/standard/test_control_connection.py b/tests/integration/standard/test_control_connection.py
index c4463e17fd..f0c41dde14 100644
--- a/tests/integration/standard/test_control_connection.py
+++ b/tests/integration/standard/test_control_connection.py
@@ -68,7 +68,7 @@ def test_drop_keyspace(self):
         self.session = self.cluster.connect()
         self.session.execute("""
             CREATE KEYSPACE keyspacetodrop
-            WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1' }
+            WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1' }
             """)
         self.session.set_keyspace("keyspacetodrop")
         self.session.execute("CREATE TYPE user (age int, name text)")
diff --git a/tests/integration/standard/test_custom_protocol_handler.py b/tests/integration/standard/test_custom_protocol_handler.py
index e123f2050e..e7d336014f 100644
--- a/tests/integration/standard/test_custom_protocol_handler.py
+++ b/tests/integration/standard/test_custom_protocol_handler.py
@@ -42,8 +42,9 @@ class CustomProtocolHandlerTest(unittest.TestCase):
     def setUpClass(cls):
         cls.cluster = TestCluster()
         cls.session = cls.cluster.connect()
-        cls.session.execute("CREATE KEYSPACE custserdes WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1'}")
+        cls.session.execute("CREATE KEYSPACE custserdes WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1'}")
         cls.session.set_keyspace("custserdes")
+        cls.session.execute("CREATE TABLE IF NOT EXISTS custserdes.test (k int PRIMARY KEY, v int)")
 
     @classmethod
     def tearDownClass(cls):
@@ -165,7 +166,7 @@ def test_protocol_divergence_v5_fail_by_flag_uses_int(self):
                                                         int_flag=False)
 
     def _send_query_message(self, session, timeout, **kwargs):
-        query = "SELECT * FROM test3rf.test"
+        query = "SELECT * FROM custserdes.test"
         message = QueryMessage(query=query, **kwargs)
         future = ResponseFuture(session, message, query=None, timeout=timeout)
         future.send_request()
@@ -175,8 +176,8 @@ def _protocol_divergence_fail_by_flag_uses_int(self, version, uses_int_query_fla
         cluster = TestCluster(protocol_version=version, allow_beta_protocol_version=beta)
         session = cluster.connect()
 
-        query_one = SimpleStatement("INSERT INTO test3rf.test (k, v) VALUES (1, 1)")
-        query_two = SimpleStatement("INSERT INTO test3rf.test (k, v) VALUES (2, 2)")
+        query_one = SimpleStatement("INSERT INTO custserdes.test (k, v) VALUES (1, 1)")
+        query_two = SimpleStatement("INSERT INTO custserdes.test (k, v) VALUES (2, 2)")
 
         execute_with_long_wait_retry(session, query_one)
         execute_with_long_wait_retry(session, query_two)
@@ -190,7 +191,7 @@ def _protocol_divergence_fail_by_flag_uses_int(self, version, uses_int_query_fla
             # This means the flag are not handled as they are meant by the server if uses_int=False
             assert response.has_more_pages == uses_int_query_flag
 
-        execute_with_long_wait_retry(session, SimpleStatement("TRUNCATE test3rf.test"))
+        execute_with_long_wait_retry(session, SimpleStatement("TRUNCATE custserdes.test"))
         cluster.shutdown()
 
 
diff --git a/tests/integration/standard/test_cython_protocol_handlers.py b/tests/integration/standard/test_cython_protocol_handlers.py
index 9c94b2ac77..49a13ac23a 100644
--- a/tests/integration/standard/test_cython_protocol_handlers.py
+++ b/tests/integration/standard/test_cython_protocol_handlers.py
@@ -34,7 +34,7 @@ def setUpClass(cls):
         cls.cluster = TestCluster()
         cls.session = cls.cluster.connect()
         cls.session.execute("CREATE KEYSPACE testspace WITH replication = "
-                            "{ 'class' : 'SimpleStrategy', 'replication_factor': '1'}")
+                            "{ 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1'}")
         cls.session.set_keyspace("testspace")
         cls.colnames = create_table_with_all_types("test_table", cls.session, cls.N_ITEMS)
 
@@ -225,7 +225,7 @@ def setUpClass(cls):
         cls.cluster = TestCluster()
         cls.session = cls.cluster.connect()
         cls.session.execute("CREATE KEYSPACE IF NOT EXISTS test_wide_table WITH replication = "
-                            "{ 'class' : 'SimpleStrategy', 'replication_factor': '1'}")
+                            "{ 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1'}")
         cls.session.set_keyspace("test_wide_table")
 
         # Create a wide table with many int columns
diff --git a/tests/integration/standard/test_metadata.py b/tests/integration/standard/test_metadata.py
index 6e64401a75..d34b81d44d 100644
--- a/tests/integration/standard/test_metadata.py
+++ b/tests/integration/standard/test_metadata.py
@@ -230,8 +230,8 @@ def test_basic_table_meta_properties(self):
 
         assert ksmeta.name == self.keyspace_name
         assert ksmeta.durable_writes
-        assert ksmeta.replication_strategy.name == 'SimpleStrategy'
-        assert ksmeta.replication_strategy.replication_factor == 1
+        assert ksmeta.replication_strategy.name == 'NetworkTopologyStrategy'
+        assert ksmeta.replication_strategy.dc_replication_factors["dc1"] == 1
 
         assert self.function_table_name in ksmeta.tables
         tablemeta = ksmeta.tables[self.function_table_name]
@@ -448,6 +448,8 @@ def test_dense_compact_storage(self):
         tablemeta = self.get_table_metadata()
         self.check_create_statement(tablemeta, create_statement)
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Counters are not yet supported with tablets',
+                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
     def test_counter(self):
         create_statement = (
             "CREATE TABLE {keyspace}.{table} ("
@@ -601,7 +603,7 @@ def test_refresh_schema_metadata(self):
         assert "new_keyspace" not in cluster2.metadata.keyspaces
 
         # Cluster metadata modification
-        self.session.execute("CREATE KEYSPACE new_keyspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}")
+        self.session.execute("CREATE KEYSPACE new_keyspace WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}")
         assert "new_keyspace" not in cluster2.metadata.keyspaces
 
         cluster2.refresh_schema_metadata()
@@ -722,6 +724,8 @@ def test_refresh_table_metadata(self):
         cluster2.shutdown()
 
     @greaterthanorequalcass30
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
     def test_refresh_metadata_for_mv(self):
         """
         test for synchronously refreshing materialized view metadata
@@ -931,6 +935,8 @@ def test_refresh_user_aggregate_metadata(self):
 
     @greaterthanorequalcass30
     @requires_collection_indexes
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
     def test_multiple_indices(self):
         """
         test multiple indices on the same column.
@@ -964,6 +970,8 @@ def test_multiple_indices(self):
         assert index_2.keyspace_name == "schemametadatatests"
 
     @greaterthanorequalcass30
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
     def test_table_extensions(self):
         s = self.session
         ks = self.keyspace_name
@@ -1077,7 +1085,7 @@ def test_metadata_pagination_keyspaces(self):
 
         for ks in keyspaces:
             self.session.execute(
-                f"CREATE KEYSPACE IF NOT EXISTS {ks} WITH REPLICATION = {{ 'class' : 'SimpleStrategy', 'replication_factor' : 3 }}"
+                f"CREATE KEYSPACE IF NOT EXISTS {ks} WITH REPLICATION = {{ 'class' : 'NetworkTopologyStrategy', 'replication_factor' : 3 }}"
             )
 
         self.cluster.schema_metadata_page_size = 2000
@@ -1138,7 +1146,7 @@ def test_export_keyspace_schema_udts(self):
 
         session.execute("""
             CREATE KEYSPACE export_udts
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
             AND durable_writes = true;
         """)
         session.execute("""
@@ -1162,7 +1170,7 @@ def test_export_keyspace_schema_udts(self):
             addresses map<text, frozen<address>>)
         """)
 
-        expected_prefix = """CREATE KEYSPACE export_udts WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}  AND durable_writes = true;
+        expected_prefix = """CREATE KEYSPACE export_udts WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}  AND durable_writes = true;
 
 CREATE TYPE export_udts.street (
     street_number int,
@@ -1212,7 +1220,7 @@ def test_case_sensitivity(self):
         session.execute("DROP KEYSPACE IF EXISTS {0}".format(ksname))
         session.execute("""
             CREATE KEYSPACE "%s"
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
             """ % (ksname,))
         session.execute("""
             CREATE TABLE "%s"."%s" (
@@ -1256,7 +1264,7 @@ def test_already_exists_exceptions(self):
 
         ddl = '''
             CREATE KEYSPACE %s
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}'''
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '3'}'''
         with pytest.raises(AlreadyExists):
             session.execute(ddl % ksname)
 
@@ -1387,7 +1395,7 @@ def setUp(self):
         self.session = self.cluster.connect()
         name = self._testMethodName.lower()
         crt_ks = '''
-                CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1} AND durable_writes = true''' % name
+                CREATE KEYSPACE %s WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 1} AND durable_writes = true''' % name
         self.session.execute(crt_ks)
 
     def tearDown(self):
@@ -1437,7 +1445,7 @@ def setup_class(cls):
             cls.session.execute(
                 """
                 CREATE KEYSPACE %s
-                WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'};
+                WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'};
                 """ % cls.keyspace_name)
             cls.session.set_keyspace(cls.keyspace_name)
         except Exception:
@@ -1540,7 +1548,7 @@ def setup_class(cls):
             cls.cluster = TestCluster()
             cls.keyspace_name = cls.__name__.lower()
             cls.session = cls.cluster.connect()
-            cls.session.execute("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}" % cls.keyspace_name)
+            cls.session.execute("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 1}" % cls.keyspace_name)
             cls.session.set_keyspace(cls.keyspace_name)
             cls.keyspace_function_meta = cls.cluster.metadata.keyspaces[cls.keyspace_name].functions
             cls.keyspace_aggregate_meta = cls.cluster.metadata.keyspaces[cls.keyspace_name].aggregates
@@ -2007,7 +2015,7 @@ def setup_class(cls):
         cls.cluster = TestCluster()
         cls.keyspace_name = cls.__name__.lower()
         cls.session = cls.cluster.connect()
-        cls.session.execute("CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}" % cls.keyspace_name)
+        cls.session.execute("CREATE KEYSPACE %s WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}" % cls.keyspace_name)
         cls.session.set_keyspace(cls.keyspace_name)
         connection = cls.cluster.control_connection._connection
 
diff --git a/tests/integration/standard/test_policies.py b/tests/integration/standard/test_policies.py
index 2de12f7b7f..50b431e3c9 100644
--- a/tests/integration/standard/test_policies.py
+++ b/tests/integration/standard/test_policies.py
@@ -104,5 +104,5 @@ def test_exponential_retries(self):
         self.session.execute(
             """
             CREATE KEYSPACE preparedtests
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
             """)
diff --git a/tests/integration/standard/test_prepared_statements.py b/tests/integration/standard/test_prepared_statements.py
index 3f63b881ef..37f93c94c6 100644
--- a/tests/integration/standard/test_prepared_statements.py
+++ b/tests/integration/standard/test_prepared_statements.py
@@ -62,7 +62,7 @@ def test_basic(self):
         self.session.execute(
             """
             CREATE KEYSPACE preparedtests
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
             """)
 
         self.session.set_keyspace("preparedtests")
@@ -437,7 +437,7 @@ def test_fail_if_different_query_id_on_reprepare(self):
         keyspace = "test_fail_if_different_query_id_on_reprepare"
         self.session.execute(
             "CREATE KEYSPACE IF NOT EXISTS {} WITH replication = "
-            "{{'class': 'SimpleStrategy', 'replication_factor': 1}}".format(keyspace)
+            "{{'class': 'NetworkTopologyStrategy', 'replication_factor': 1}}".format(keyspace)
         )
         self.session.execute("CREATE TABLE IF NOT EXISTS {}.foo(k int PRIMARY KEY)".format(keyspace))
         prepared = self.session.prepare("SELECT * FROM {}.foo WHERE k=?".format(keyspace))
diff --git a/tests/integration/standard/test_query.py b/tests/integration/standard/test_query.py
index f9d3dc26bc..91ad4fa559 100644
--- a/tests/integration/standard/test_query.py
+++ b/tests/integration/standard/test_query.py
@@ -1359,12 +1359,12 @@ def setUpClass(cls):
         cls.table_name = "table_query_keyspace_tests"
 
         ddl = """CREATE KEYSPACE {0} WITH replication =
-                        {{'class': 'SimpleStrategy',
+                        {{'class': 'NetworkTopologyStrategy',
                         'replication_factor': '{1}'}}""".format(cls.ks_name, 1)
         cls.session.execute(ddl)
 
         ddl = """CREATE KEYSPACE {0} WITH replication =
-                                {{'class': 'SimpleStrategy',
+                                {{'class': 'NetworkTopologyStrategy',
                                 'replication_factor': '{1}'}}""".format(cls.alternative_ks, 1)
         cls.session.execute(ddl)
 
diff --git a/tests/integration/standard/test_rate_limit_exceeded.py b/tests/integration/standard/test_rate_limit_exceeded.py
index ea7dfc7d61..5a7fc5dc74 100644
--- a/tests/integration/standard/test_rate_limit_exceeded.py
+++ b/tests/integration/standard/test_rate_limit_exceeded.py
@@ -33,7 +33,7 @@ def test_rate_limit_exceeded(self):
         self.session.execute(
             """
             CREATE KEYSPACE IF NOT EXISTS ratetests
-            WITH REPLICATION = {'class' : 'SimpleStrategy', 'replication_factor' : 1}
+            WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'replication_factor' : 1}
             """)
 
         self.session.execute("USE ratetests")
diff --git a/tests/integration/standard/test_shard_aware.py b/tests/integration/standard/test_shard_aware.py
index d1f3e27abd..4a6c7887d8 100644
--- a/tests/integration/standard/test_shard_aware.py
+++ b/tests/integration/standard/test_shard_aware.py
@@ -89,7 +89,7 @@ def create_ks_and_cf(self):
         self.session.execute(
             """
             CREATE KEYSPACE preparedtests
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '3'} AND tablets = {'enabled': false}
             """)
 
         self.session.execute("USE preparedtests")
@@ -174,6 +174,8 @@ def test_all_tracing_coming_one_shard(self):
 
         using the traces to validate that all the action been executed on the the same shard.
         this test is using prepared SELECT statements for this validation
+
+        Requires tablets to be disabled to ensure shard consistency.
         """
 
         self.create_ks_and_cf()
diff --git a/tests/integration/standard/test_tablets.py b/tests/integration/standard/test_tablets.py
index d969140339..45e8a807ea 100644
--- a/tests/integration/standard/test_tablets.py
+++ b/tests/integration/standard/test_tablets.py
@@ -9,7 +9,7 @@
 
 
 def setup_module():
-    use_cluster('tablets', [3], start=True)
+    use_cluster('tablets', [3], start=True, set_keyspace=False)
 
 
 class TestTabletsIntegration:
diff --git a/tests/integration/standard/test_udts.py b/tests/integration/standard/test_udts.py
index 18f3dfb298..11888adda4 100644
--- a/tests/integration/standard/test_udts.py
+++ b/tests/integration/standard/test_udts.py
@@ -94,7 +94,7 @@ def test_can_insert_unprepared_registered_udts(self):
         # use the same UDT name in a different keyspace
         s.execute("""
             CREATE KEYSPACE udt_test_unprepared_registered2
-            WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1' }
+            WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1' }
             """)
         s.set_keyspace("udt_test_unprepared_registered2")
         s.execute("CREATE TYPE user (state text, is_cool boolean)")
@@ -124,14 +124,14 @@ def test_can_register_udt_before_connecting(self):
 
         s.execute("""
             CREATE KEYSPACE udt_test_register_before_connecting
-            WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1' }
+            WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1' }
             """)
         s.execute("CREATE TYPE udt_test_register_before_connecting.user (age int, name text)")
         s.execute("CREATE TABLE udt_test_register_before_connecting.mytable (a int PRIMARY KEY, b frozen<user>)")
 
         s.execute("""
             CREATE KEYSPACE udt_test_register_before_connecting2
-            WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1' }
+            WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1' }
             """)
         s.execute("CREATE TYPE udt_test_register_before_connecting2.user (state text, is_cool boolean)")
         s.execute("CREATE TABLE udt_test_register_before_connecting2.mytable (a int PRIMARY KEY, b frozen<user>)")
@@ -193,7 +193,7 @@ def test_can_insert_prepared_unregistered_udts(self):
         # use the same UDT name in a different keyspace
         s.execute("""
             CREATE KEYSPACE udt_test_prepared_unregistered2
-            WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1' }
+            WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1' }
             """)
         s.set_keyspace("udt_test_prepared_unregistered2")
         s.execute("CREATE TYPE user (state text, is_cool boolean)")
@@ -240,7 +240,7 @@ def test_can_insert_prepared_registered_udts(self):
         # use the same UDT name in a different keyspace
         s.execute("""
             CREATE KEYSPACE udt_test_prepared_registered2
-            WITH replication = { 'class' : 'SimpleStrategy', 'replication_factor': '1' }
+            WITH replication = { 'class' : 'NetworkTopologyStrategy', 'replication_factor': '1' }
             """)
         s.set_keyspace("udt_test_prepared_registered2")
         s.execute("CREATE TYPE user (state text, is_cool boolean)")
diff --git a/tests/integration/standard/test_use_keyspace.py b/tests/integration/standard/test_use_keyspace.py
index 80e7cfe5f3..9eb3f5be36 100644
--- a/tests/integration/standard/test_use_keyspace.py
+++ b/tests/integration/standard/test_use_keyspace.py
@@ -65,7 +65,7 @@ def patched_set_keyspace_blocking(*args, **kwargs):
             return original_set_keyspace_blocking(*args, **kwargs)
 
         with patch.object(Connection, "set_keyspace_blocking", patched_set_keyspace_blocking):
-            self.session.execute("CREATE KEYSPACE test_set_keyspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}")
+            self.session.execute("CREATE KEYSPACE test_set_keyspace WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 1}")
             self.session.execute("CREATE TABLE test_set_keyspace.set_keyspace_slow_connection(pk int, PRIMARY KEY(pk))")
 
             session2 = self.cluster.connect()

From 445b5afb4a08690f933beb6e4b70cdd1b1e8d8fb Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Wed, 22 Apr 2026 14:10:57 +0200
Subject: [PATCH 39/49] tests: bootstrap 3 new nodes in full node replacement
 test

With tablets enabled, decommissioning a node from a 3-node cluster with
RF=3 fails because there is no available node to receive tablet replicas.
Bootstrap 3 replacement nodes instead of 2 so that each original node
can be decommissioned while sufficient replicas remain.
---
 tests/integration/standard/test_client_routes.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/integration/standard/test_client_routes.py b/tests/integration/standard/test_client_routes.py
index 290d1741f7..292eabca30 100644
--- a/tests/integration/standard/test_client_routes.py
+++ b/tests/integration/standard/test_client_routes.py
@@ -1154,7 +1154,7 @@ def tearDownClass(cls):
     def test_should_survive_full_node_replacement_through_nlb(self):
         """
         1. Start with 3 nodes behind the NLB
-        2. Bootstrap 2 new nodes, add to NLB, update routes
+        2. Bootstrap 3 new nodes, add to NLB, update routes
         3. Decommission the original 3 nodes one-by-one, updating NLB/routes
         4. Verify the session survives with only new nodes
         """
@@ -1190,7 +1190,7 @@ def test_should_survive_full_node_replacement_through_nlb(self):
                          len(original_node_ids))
 
                 # ---- Stage 3: Bootstrap new nodes ----
-                new_node_ids = [max(original_node_ids) + 1, max(original_node_ids) + 2]
+                new_node_ids = [max(original_node_ids) + 1, max(original_node_ids) + 2, max(original_node_ids) + 3]
                 log.info("Stage 3: Adding nodes %s", new_node_ids)
                 ccm_cluster = get_cluster()
 

From 2b5dd164a3c047fe4826b2df1815562842fd1e4c Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Thu, 23 Apr 2026 08:16:51 +0200
Subject: [PATCH 40/49] tests: xfail LWT tests on Scylla versions without
 tablet LWT support

LWT is not supported with tablets on ScyllaDB < 2025.4. Mark the affected SerialConsistencyTests and
LightweightTransactionTests as xfail for those versions.
---
 tests/integration/standard/test_query.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/tests/integration/standard/test_query.py b/tests/integration/standard/test_query.py
index 91ad4fa559..4f460459c0 100644
--- a/tests/integration/standard/test_query.py
+++ b/tests/integration/standard/test_query.py
@@ -26,7 +26,7 @@
 from cassandra.policies import HostDistance, RoundRobinPolicy, WhiteListRoundRobinPolicy
 from tests.integration import use_singledc, PROTOCOL_VERSION, BasicSharedKeyspaceUnitTestCase, \
     greaterthanprotocolv3, MockLoggingHandler, get_supported_protocol_versions, local, get_cluster, setup_keyspace, \
-    USE_CASS_EXTERNAL, greaterthanorequalcass40, TestCluster, xfail_scylla
+    USE_CASS_EXTERNAL, greaterthanorequalcass40, TestCluster, xfail_scylla, xfail_scylla_version_lt
 from tests import notwindows
 from tests.integration import greaterthanorequalcass30, get_node
 from tests.util import assertListEqual, wait_until
@@ -804,6 +804,9 @@ def setUp(self):
     def tearDown(self):
         self.cluster.shutdown()
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#18068 - LWT is not yet supported with tablets',
+                             scylla_version='2025.4',
+                             raises=InvalidRequest)
     def test_conditional_update(self):
         self.session.execute("INSERT INTO test3rf.test (k, v) VALUES (0, 0)")
         statement = SimpleStatement(
@@ -828,6 +831,9 @@ def test_conditional_update(self):
         assert result
         assert result.one().applied
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#18068 - LWT is not yet supported with tablets',
+                             scylla_version='2025.4',
+                             raises=InvalidRequest)
     def test_conditional_update_with_prepared_statements(self):
         self.session.execute("INSERT INTO test3rf.test (k, v) VALUES (0, 0)")
         statement = self.session.prepare(
@@ -850,6 +856,9 @@ def test_conditional_update_with_prepared_statements(self):
         assert result
         assert result.one().applied
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#18068 - LWT is not yet supported with tablets',
+                             scylla_version='2025.4',
+                             raises=InvalidRequest)
     def test_conditional_update_with_batch_statements(self):
         self.session.execute("INSERT INTO test3rf.test (k, v) VALUES (0, 0)")
         statement = BatchStatement(serial_consistency_level=ConsistencyLevel.SERIAL)
@@ -915,6 +924,9 @@ def tearDown(self):
         self.session.execute("DROP TABLE test3rf.lwt_clustering")
         self.cluster.shutdown()
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#18068 - LWT is not yet supported with tablets',
+                             scylla_version='2025.4',
+                             raises=AttributeError)
     def test_no_connection_refused_on_timeout(self):
         """
         Test for PYTHON-91 "Connection closed after LWT timeout"

From e7cb651ad863f60c48eca1b924b1236445507eb2 Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Mon, 4 May 2026 16:04:03 +0200
Subject: [PATCH 41/49] tests: xfail tests on Scylla version without indexes
 tablet support

Secondary indexes are not supported on base tables with tablets for Scylla
versions < 2026.1.
---
 .../integration/cqlengine/query/test_named.py |  4 +++-
 tests/integration/standard/test_metadata.py   | 22 ++++++++++++++-----
 tests/integration/standard/test_query.py      |  2 ++
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/tests/integration/cqlengine/query/test_named.py b/tests/integration/cqlengine/query/test_named.py
index 24a6802b47..4923a8a583 100644
--- a/tests/integration/cqlengine/query/test_named.py
+++ b/tests/integration/cqlengine/query/test_named.py
@@ -27,7 +27,7 @@
 from tests.integration.cqlengine.query.test_queryset import BaseQuerySetUsage
 
 
-from tests.integration import BasicSharedKeyspaceUnitTestCase, greaterthanorequalcass30, requires_collection_indexes
+from tests.integration import BasicSharedKeyspaceUnitTestCase, greaterthanorequalcass30, requires_collection_indexes, xfail_scylla_version_lt
 import pytest
 
 
@@ -292,6 +292,8 @@ def tearDownClass(cls):
         super(TestNamedWithMV, cls).tearDownClass()
 
     @greaterthanorequalcass30
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Materialized views and secondary indexes are not supported on base tables with tablets.',
+                             scylla_version='2026.1')
     @execute_count(5)
     def test_named_table_with_mv(self):
         """
diff --git a/tests/integration/standard/test_metadata.py b/tests/integration/standard/test_metadata.py
index d34b81d44d..84ec6c9ea5 100644
--- a/tests/integration/standard/test_metadata.py
+++ b/tests/integration/standard/test_metadata.py
@@ -449,7 +449,7 @@ def test_dense_compact_storage(self):
         self.check_create_statement(tablemeta, create_statement)
 
     @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Counters are not yet supported with tablets',
-                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
+                             scylla_version="2026.1")
     def test_counter(self):
         create_statement = (
             "CREATE TABLE {keyspace}.{table} ("
@@ -725,7 +725,7 @@ def test_refresh_table_metadata(self):
 
     @greaterthanorequalcass30
     @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
+                             scylla_version="2026.1")
     def test_refresh_metadata_for_mv(self):
         """
         test for synchronously refreshing materialized view metadata
@@ -936,7 +936,7 @@ def test_refresh_user_aggregate_metadata(self):
     @greaterthanorequalcass30
     @requires_collection_indexes
     @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
+                             scylla_version="2026.1")
     def test_multiple_indices(self):
         """
         test multiple indices on the same column.
@@ -971,7 +971,7 @@ def test_multiple_indices(self):
 
     @greaterthanorequalcass30
     @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             oss_scylla_version="7.0", ent_scylla_version="2026.1")
+                             scylla_version="2026.1")
     def test_table_extensions(self):
         s = self.session
         ks = self.keyspace_name
@@ -1204,8 +1204,8 @@ def test_export_keyspace_schema_udts(self):
         cluster.shutdown()
 
     @greaterthancass21
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#10707 - Column name in CREATE INDEX is not quoted',
-                             scylla_version="2023.1.1")
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             scylla_version="2026.1")
     def test_case_sensitivity(self):
         """
         Test that names that need to be escaped in CREATE statements are
@@ -1465,6 +1465,8 @@ def create_basic_table(self):
     def drop_basic_table(self):
         self.session.execute("DROP TABLE %s" % self.table_name)
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             scylla_version="2026.1")
     def test_index_updates(self):
         self.create_basic_table()
 
@@ -1506,6 +1508,8 @@ def test_index_updates(self):
         assert 'a_idx' not in ks_meta.indexes
         assert 'b_idx' not in ks_meta.indexes
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             scylla_version="2026.1")
     def test_index_follows_alter(self):
         self.create_basic_table()
 
@@ -2047,6 +2051,8 @@ def test_bad_table(self):
             assert m._exc_info[0] is self.BadMetaException
             assert "/*\nWarning:" in m.export_as_string()
 
+    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             scylla_version="2026.1")
     def test_bad_index(self):
         self.session.execute('CREATE TABLE %s (k int PRIMARY KEY, v int)' % self.function_name)
         self.session.execute('CREATE INDEX ON %s(v)' % self.function_name)
@@ -2138,6 +2144,8 @@ def test_dct_alias(self):
 
 
 @greaterthanorequalcass30
+@xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                         scylla_version="2026.1")
 class MaterializedViewMetadataTestSimple(BasicSharedKeyspaceUnitTestCase):
 
     def setUp(self):
@@ -2226,6 +2234,8 @@ def test_materialized_view_metadata_drop(self):
 
 
 @greaterthanorequalcass30
+@xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
+                             scylla_version="2026.1")
 class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
     def test_create_view_metadata(self):
         """
diff --git a/tests/integration/standard/test_query.py b/tests/integration/standard/test_query.py
index 4f460459c0..5ae9242ac0 100644
--- a/tests/integration/standard/test_query.py
+++ b/tests/integration/standard/test_query.py
@@ -1166,6 +1166,8 @@ def test_inherit_first_rk_prepared_param(self):
 
 
 @greaterthanorequalcass30
+@xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Materialized views and secondary indexes are not supported on base tables with tablets.',
+                         scylla_version='2026.1')
 class MaterializedViewQueryTest(BasicSharedKeyspaceUnitTestCase):
 
     def test_mv_filtering(self):

From fe2a9432bbc8f77cd22f215d54ef9ac57b578b8f Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Tue, 5 May 2026 08:59:48 +0200
Subject: [PATCH 42/49] test_replicas_are_queried: use dedicated keyspace with
 RF=1 and tablets disabled

---
 tests/integration/standard/test_cluster.py | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/tests/integration/standard/test_cluster.py b/tests/integration/standard/test_cluster.py
index 15e525f43c..00ea11ea27 100644
--- a/tests/integration/standard/test_cluster.py
+++ b/tests/integration/standard/test_cluster.py
@@ -1195,27 +1195,35 @@ def test_replicas_are_queried(self):
         Then using HostFilterPolicy the replica is excluded from the considered hosts.
         By checking the trace we verify that there are no more replicas.
 
+        Requires tablets feature disabled.
+
         @since 3.5
         @jira_ticket PYTHON-653
         @expected_result the replicas are queried for HostFilterPolicy
 
         @test_category metadata
         """
+        ks_name = 'test_replicas_queried_ks'
         queried_hosts = set()
         tap_profile = ExecutionProfile(
             load_balancing_policy=TokenAwarePolicy(RoundRobinPolicy())
         )
         with TestCluster(execution_profiles={EXEC_PROFILE_DEFAULT: tap_profile}) as cluster:
             session = cluster.connect(wait_for_all_pools=True)
+            session.execute("DROP KEYSPACE IF EXISTS {}".format(ks_name))
+            session.execute(
+                "CREATE KEYSPACE {} WITH replication = {{'class': 'NetworkTopologyStrategy', "
+                "'replication_factor': '1'}} AND tablets = {{'enabled': false}}".format(ks_name)
+            )
             session.execute('''
-                    CREATE TABLE test1rf.table_with_big_key (
+                    CREATE TABLE {}.table_with_big_key (
                         k1 int,
                         k2 int,
                         k3 int,
                         k4 int,
-                        PRIMARY KEY((k1, k2, k3), k4))''')
-            prepared = session.prepare("""SELECT * from test1rf.table_with_big_key
-                                          WHERE k1 = ? AND k2 = ? AND k3 = ? AND k4 = ?""")
+                        PRIMARY KEY((k1, k2, k3), k4))'''.format(ks_name))
+            prepared = session.prepare("""SELECT * from {}.table_with_big_key
+                                          WHERE k1 = ? AND k2 = ? AND k3 = ? AND k4 = ?""".format(ks_name))
             for i in range(10):
                 result = session.execute(prepared, (i, i, i, i), trace=True)
                 trace = result.response_future.get_query_trace(query_cl=ConsistencyLevel.ALL)
@@ -1234,14 +1242,14 @@ def test_replicas_are_queried(self):
                          execution_profiles={EXEC_PROFILE_DEFAULT: hfp_profile}) as cluster:
 
             session = cluster.connect(wait_for_all_pools=True)
-            prepared = session.prepare("""SELECT * from test1rf.table_with_big_key
-                                          WHERE k1 = ? AND k2 = ? AND k3 = ? AND k4 = ?""")
+            prepared = session.prepare("""SELECT * from {}.table_with_big_key
+                                          WHERE k1 = ? AND k2 = ? AND k3 = ? AND k4 = ?""".format(ks_name))
             for _ in range(10):
                 result = session.execute(prepared, (last_i, last_i, last_i, last_i), trace=True)
                 trace = result.response_future.get_query_trace(query_cl=ConsistencyLevel.ALL)
                 self._assert_replica_queried(trace, only_replicas=False)
 
-            session.execute('''DROP TABLE test1rf.table_with_big_key''')
+            session.execute('DROP KEYSPACE {}'.format(ks_name))
 
     @greaterthanorequalcass30
     @lessthanorequalcass40

From b9813e7be1dc139595dd977cf05251431b3ec716 Mon Sep 17 00:00:00 2001
From: Yaniv Michael Kaul <yaniv.kaul@scylladb.com>
Date: Sun, 29 Mar 2026 10:05:23 +0300
Subject: [PATCH 43/49] ci: update Scylla test version from 2025.2 to 2026.1
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The integration test suite was pinned to release:2025.2 which is no
longer the latest LTS branch.  Update to release:2026.1 so CI covers
the newest ScyllaDB features and catches regressions earlier.

Tests gated by @skip_scylla_version_lt(2026.1.0) — such as the
client_routes tests — will now actually execute in CI.
---
 .github/workflows/integration-tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index fde1ab3e1d..61261aadf8 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -38,7 +38,7 @@ jobs:
     if: "!contains(github.event.pull_request.labels.*.name, 'disable-integration-tests')"
     runs-on: ubuntu-24.04
     env:
-      SCYLLA_VERSION: release:2025.2
+      SCYLLA_VERSION: release:2026.1
     strategy:
       fail-fast: false
       matrix:

From fb13815c7622f5ec65e8655d667171dd72503afe Mon Sep 17 00:00:00 2001
From: Roy Dahan <roy@scylladb.com>
Date: Mon, 11 May 2026 19:53:47 +0300
Subject: [PATCH 44/49] Replace SimpleStrategy with NetworkTopologyStrategy
 across codebase

ScyllaDB has dropped support for SimpleStrategy. Update all CQL
statements, test fixtures, examples, benchmarks, and management
utilities to use NetworkTopologyStrategy instead.

The SimpleStrategy class definition in cassandra/metadata.py is
preserved for backward compatibility with Cassandra clusters.
---
 benchmarks/base.py                            |  2 +-
 cassandra/cqlengine/management.py             |  6 +-
 docs/scylla-specific.rst                      |  2 +-
 .../execute_async_with_queue.py               |  2 +-
 .../execute_with_threads.py                   |  2 +-
 examples/example_core.py                      |  2 +-
 .../cqlengine/connections/test_connection.py  |  4 +-
 tests/integration/long/test_failure_types.py  |  2 +-
 tests/integration/long/test_policies.py       |  2 +-
 tests/integration/long/test_schema.py         | 12 ++--
 tests/integration/long/test_ssl.py            |  4 +-
 tests/integration/long/utils.py               |  2 +-
 .../simulacron/test_empty_column.py           |  4 +-
 tests/unit/advanced/test_metadata.py          |  4 +-
 tests/unit/test_metadata.py                   | 66 +++++++++----------
 15 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/benchmarks/base.py b/benchmarks/base.py
index d9cd004474..3922eefad5 100644
--- a/benchmarks/base.py
+++ b/benchmarks/base.py
@@ -97,7 +97,7 @@ def setup(options):
         try:
             session.execute("""
                 CREATE KEYSPACE %s
-                WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '2' }
+                WITH replication = { 'class': 'NetworkTopologyStrategy', 'replication_factor': '2' }
                 """ % options.keyspace)
 
             log.debug("Setting keyspace...")
diff --git a/cassandra/cqlengine/management.py b/cassandra/cqlengine/management.py
index d6dc44119a..684bc50b8a 100644
--- a/cassandra/cqlengine/management.py
+++ b/cassandra/cqlengine/management.py
@@ -56,7 +56,7 @@ def _get_context(keyspaces, connections):
 
 def create_keyspace_simple(name, replication_factor, durable_writes=True, connections=None):
     """
-    Creates a keyspace with SimpleStrategy for replica placement
+    Creates a keyspace with NetworkTopologyStrategy for replica placement
 
     If the keyspace already exists, it will not be modified.
 
@@ -66,11 +66,11 @@ def create_keyspace_simple(name, replication_factor, durable_writes=True, connec
     *There are plans to guard schema-modifying functions with an environment-driven conditional.*
 
     :param str name: name of keyspace to create
-    :param int replication_factor: keyspace replication factor, used with :attr:`~.SimpleStrategy`
+    :param int replication_factor: keyspace replication factor, used with :attr:`~.NetworkTopologyStrategy`
     :param bool durable_writes: Write log is bypassed if set to False
     :param list connections: List of connection names
     """
-    _create_keyspace(name, durable_writes, 'SimpleStrategy',
+    _create_keyspace(name, durable_writes, 'NetworkTopologyStrategy',
                      {'replication_factor': replication_factor}, connections=connections)
 
 
diff --git a/docs/scylla-specific.rst b/docs/scylla-specific.rst
index e9fe695f8f..4b28781f1c 100644
--- a/docs/scylla-specific.rst
+++ b/docs/scylla-specific.rst
@@ -91,7 +91,7 @@ New Error Types
     session = cluster.connect()
     session.execute("""
         CREATE KEYSPACE IF NOT EXISTS keyspace1 
-        WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}
+        WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
     """)
 
     session.execute("USE keyspace1")
diff --git a/examples/concurrent_executions/execute_async_with_queue.py b/examples/concurrent_executions/execute_async_with_queue.py
index 72d2c101cb..794ac78818 100644
--- a/examples/concurrent_executions/execute_async_with_queue.py
+++ b/examples/concurrent_executions/execute_async_with_queue.py
@@ -31,7 +31,7 @@
 session = cluster.connect()
 
 session.execute(("CREATE KEYSPACE IF NOT EXISTS examples "
-                 "WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1' }"))
+                 "WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1' }"))
 session.execute("USE examples")
 session.execute("CREATE TABLE IF NOT EXISTS tbl_sample_kv (id uuid, value text, PRIMARY KEY (id))")
 prepared_insert = session.prepare("INSERT INTO tbl_sample_kv (id, value) VALUES (?, ?)")
diff --git a/examples/concurrent_executions/execute_with_threads.py b/examples/concurrent_executions/execute_with_threads.py
index e3c80f5d6b..70893bd5be 100644
--- a/examples/concurrent_executions/execute_with_threads.py
+++ b/examples/concurrent_executions/execute_with_threads.py
@@ -34,7 +34,7 @@
 session = cluster.connect()
 
 session.execute(("CREATE KEYSPACE IF NOT EXISTS examples "
-                 "WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1' }"))
+                 "WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1' }"))
 session.execute("USE examples")
 session.execute("CREATE TABLE IF NOT EXISTS tbl_sample_kv (id uuid, value text, PRIMARY KEY (id))")
 prepared_insert = session.prepare("INSERT INTO tbl_sample_kv (id, value) VALUES (?, ?)")
diff --git a/examples/example_core.py b/examples/example_core.py
index 01c766e109..ec41ca7fd5 100644
--- a/examples/example_core.py
+++ b/examples/example_core.py
@@ -36,7 +36,7 @@ def main():
     log.info("creating keyspace...")
     session.execute("""
         CREATE KEYSPACE IF NOT EXISTS %s
-        WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '2' }
+        WITH replication = { 'class': 'NetworkTopologyStrategy', 'replication_factor': '2' }
         """ % KEYSPACE)
 
     log.info("setting keyspace...")
diff --git a/tests/integration/cqlengine/connections/test_connection.py b/tests/integration/cqlengine/connections/test_connection.py
index 78d5133e63..640c953285 100644
--- a/tests/integration/cqlengine/connections/test_connection.py
+++ b/tests/integration/cqlengine/connections/test_connection.py
@@ -76,9 +76,9 @@ def setUpClass(cls):
         super(SeveralConnectionsTest, cls).setUpClass()
         cls.setup_cluster = TestCluster()
         cls.setup_session = cls.setup_cluster.connect()
-        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace1, 1)
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace1, 1)
         execute_with_long_wait_retry(cls.setup_session, ddl)
-        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace2, 1)
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace2, 1)
         execute_with_long_wait_retry(cls.setup_session, ddl)
 
     @classmethod
diff --git a/tests/integration/long/test_failure_types.py b/tests/integration/long/test_failure_types.py
index beb10f02c0..04d75555f5 100644
--- a/tests/integration/long/test_failure_types.py
+++ b/tests/integration/long/test_failure_types.py
@@ -187,7 +187,7 @@ def test_write_failures_from_coordinator(self):
         self._perform_cql_statement(
             """
             CREATE KEYSPACE testksfail
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '3'}
             """, consistency_level=ConsistencyLevel.ALL, expected_exception=None)
 
         # create table
diff --git a/tests/integration/long/test_policies.py b/tests/integration/long/test_policies.py
index ab8d125ab1..5cada34d8b 100644
--- a/tests/integration/long/test_policies.py
+++ b/tests/integration/long/test_policies.py
@@ -48,7 +48,7 @@ def test_should_rethrow_on_unvailable_with_default_policy_if_cas(self):
         cluster = TestCluster(execution_profiles={EXEC_PROFILE_DEFAULT: ep})
         session = cluster.connect()
 
-        session.execute("CREATE KEYSPACE test_retry_policy_cas WITH replication = {'class':'SimpleStrategy','replication_factor': 3};")
+        session.execute("CREATE KEYSPACE test_retry_policy_cas WITH replication = {'class':'NetworkTopologyStrategy','replication_factor': 3};")
         session.execute("CREATE TABLE test_retry_policy_cas.t (id int PRIMARY KEY, data text);")
         session.execute('INSERT INTO test_retry_policy_cas.t ("id", "data") VALUES (%(0)s, %(1)s)', {'0': 42, '1': 'testing'})
 
diff --git a/tests/integration/long/test_schema.py b/tests/integration/long/test_schema.py
index 3b4dcd33d5..d60ff775c4 100644
--- a/tests/integration/long/test_schema.py
+++ b/tests/integration/long/test_schema.py
@@ -57,7 +57,7 @@ def test_recreates(self):
                     log.debug(drop)
                     execute_until_pass(session, drop)
 
-                create = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': 3}}".format(keyspace)
+                create = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': 3}}".format(keyspace)
                 log.debug(create)
                 execute_until_pass(session, create)
 
@@ -82,7 +82,7 @@ def test_for_schema_disagreements_different_keyspaces(self):
         session = self.session
 
         for i in range(30):
-            execute_until_pass(session, "CREATE KEYSPACE test_{0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': 1}}".format(i))
+            execute_until_pass(session, "CREATE KEYSPACE test_{0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': 1}}".format(i))
             execute_until_pass(session, "CREATE TABLE test_{0}.cf (key int PRIMARY KEY, value int)".format(i))
 
             for j in range(100):
@@ -100,10 +100,10 @@ def test_for_schema_disagreements_same_keyspace(self):
 
         for i in range(30):
             try:
-                execute_until_pass(session, "CREATE KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}")
+                execute_until_pass(session, "CREATE KEYSPACE test WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 1}")
             except AlreadyExists:
                 execute_until_pass(session, "DROP KEYSPACE test")
-                execute_until_pass(session, "CREATE KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1}")
+                execute_until_pass(session, "CREATE KEYSPACE test WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 1}")
 
             execute_until_pass(session, "CREATE TABLE test.cf (key int PRIMARY KEY, value int)")
 
@@ -132,7 +132,7 @@ def test_for_schema_disagreement_attribute(self):
         cluster = TestCluster(max_schema_agreement_wait=0.001)
         session = cluster.connect(wait_for_all_pools=True)
 
-        rs = session.execute("CREATE KEYSPACE test_schema_disagreement WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3}")
+        rs = session.execute("CREATE KEYSPACE test_schema_disagreement WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 3}")
         self.check_and_wait_for_agreement(session, rs, False)
         rs = session.execute(SimpleStatement("CREATE TABLE test_schema_disagreement.cf (key int PRIMARY KEY, value int)",
                                              consistency_level=ConsistencyLevel.ALL))
@@ -144,7 +144,7 @@ def test_for_schema_disagreement_attribute(self):
         # These should have schema agreement
         cluster = TestCluster(max_schema_agreement_wait=100)
         session = cluster.connect()
-        rs = session.execute("CREATE KEYSPACE test_schema_disagreement WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3}")
+        rs = session.execute("CREATE KEYSPACE test_schema_disagreement WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': 3}")
         self.check_and_wait_for_agreement(session, rs, True)
         rs = session.execute(SimpleStatement("CREATE TABLE test_schema_disagreement.cf (key int PRIMARY KEY, value int)",
                                              consistency_level=ConsistencyLevel.ALL))
diff --git a/tests/integration/long/test_ssl.py b/tests/integration/long/test_ssl.py
index 56dc6a5c2d..0170f56fa1 100644
--- a/tests/integration/long/test_ssl.py
+++ b/tests/integration/long/test_ssl.py
@@ -116,7 +116,7 @@ def validate_ssl_options(**kwargs):
 
         # attempt a few simple commands.
         insert_keyspace = """CREATE KEYSPACE ssltest
-            WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}
+            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '3'}
             """
         statement = SimpleStatement(insert_keyspace)
         statement.consistency_level = 3
@@ -369,7 +369,7 @@ def test_ssl_want_write_errors_are_retried(self):
         except:
             pass
         session.execute(
-            "CREATE KEYSPACE ssl_error_test WITH replication = {'class':'SimpleStrategy','replication_factor':1};")
+            "CREATE KEYSPACE ssl_error_test WITH replication = {'class':'NetworkTopologyStrategy','replication_factor':1};")
         session.execute("CREATE TABLE ssl_error_test.big_text (id uuid PRIMARY KEY, data text);")
 
         params = {
diff --git a/tests/integration/long/utils.py b/tests/integration/long/utils.py
index 93464df8ff..ba9351828e 100644
--- a/tests/integration/long/utils.py
+++ b/tests/integration/long/utils.py
@@ -63,7 +63,7 @@ def create_schema(cluster, session, keyspace, simple_strategy=True,
 
     if simple_strategy:
         ddl = "CREATE KEYSPACE %s WITH replication" \
-              " = {'class': 'SimpleStrategy', 'replication_factor': '%s'}"
+              " = {'class': 'NetworkTopologyStrategy', 'replication_factor': '%s'}"
         session.execute(ddl % (keyspace, replication_factor), timeout=10)
     else:
         if not replication_strategy:
diff --git a/tests/integration/simulacron/test_empty_column.py b/tests/integration/simulacron/test_empty_column.py
index 2dbf3985ad..daa9f20fa8 100644
--- a/tests/integration/simulacron/test_empty_column.py
+++ b/tests/integration/simulacron/test_empty_column.py
@@ -140,9 +140,9 @@ def test_empty_columns_in_system_schema(self):
             'delay_in_ms': 0,
             'rows': [
                 {
-                    "strategy_class": "SimpleStrategy",  # C* 2.2
+                    "strategy_class": "NetworkTopologyStrategy",  # C* 2.2
                     "strategy_options": '{}',  # C* 2.2
-                    "replication": {'strategy': 'SimpleStrategy', 'replication_factor': 1},
+                    "replication": {'strategy': 'NetworkTopologyStrategy', 'replication_factor': 1},
                     "durable_writes": True,
                     "keyspace_name": "testks"
                 }
diff --git a/tests/unit/advanced/test_metadata.py b/tests/unit/advanced/test_metadata.py
index 5ccfa5e477..d68a87961d 100644
--- a/tests/unit/advanced/test_metadata.py
+++ b/tests/unit/advanced/test_metadata.py
@@ -34,8 +34,8 @@ def _create_vertex_metadata(self, label_name='label'):
 
     def _create_keyspace_metadata(self, graph_engine):
         return KeyspaceMetadata(
-            'keyspace', True, 'org.apache.cassandra.locator.SimpleStrategy',
-            {'replication_factor': 1}, graph_engine=graph_engine)
+            'keyspace', True, 'org.apache.cassandra.locator.NetworkTopologyStrategy',
+            {'dc1': 1}, graph_engine=graph_engine)
 
     def _create_table_metadata(self, with_vertex=False, with_edge=False):
         tm = TableMetadataDSE68('keyspace', 'table')
diff --git a/tests/unit/test_metadata.py b/tests/unit/test_metadata.py
index dcbb840447..15cf283777 100644
--- a/tests/unit/test_metadata.py
+++ b/tests/unit/test_metadata.py
@@ -25,7 +25,7 @@
 from cassandra.marshal import uint16_unpack, uint16_pack
 from cassandra.metadata import (Murmur3Token, MD5Token,
                                 BytesToken, ReplicationStrategy,
-                                NetworkTopologyStrategy, SimpleStrategy,
+                                NetworkTopologyStrategy,
                                 LocalStrategy, protect_name,
                                 protect_names, protect_value, is_valid_name,
                                 UserType, KeyspaceMetadata, get_schema_parser,
@@ -96,14 +96,14 @@ def test_replication_strategy(self):
         assert rs.create('NetworkTopologyStrategy', fake_options_map).dc_replication_factors == NetworkTopologyStrategy(fake_options_map).dc_replication_factors
 
         fake_options_map = {'options': 'map'}
-        assert rs.create('SimpleStrategy', fake_options_map) is None
+        assert rs.create('NetworkTopologyStrategy', fake_options_map) is None
 
         fake_options_map = {'options': 'map'}
         assert isinstance(rs.create('LocalStrategy', fake_options_map), LocalStrategy)
 
-        fake_options_map = {'options': 'map', 'replication_factor': 3}
-        assert isinstance(rs.create('SimpleStrategy', fake_options_map), SimpleStrategy)
-        assert rs.create('SimpleStrategy', fake_options_map).replication_factor == SimpleStrategy(fake_options_map).replication_factor
+        fake_options_map = {'dc1': 3}
+        assert isinstance(rs.create('NetworkTopologyStrategy', fake_options_map), NetworkTopologyStrategy)
+        assert rs.create('NetworkTopologyStrategy', fake_options_map).dc_replication_factors == NetworkTopologyStrategy(fake_options_map).dc_replication_factors
 
         assert rs.create('xxxxxxxx', fake_options_map) == _UnknownStrategy('xxxxxxxx', fake_options_map)
 
@@ -113,38 +113,38 @@ def test_replication_strategy(self):
             rs.export_for_schema()
 
     def test_simple_replication_type_parsing(self):
-        """ Test equality between passing numeric and string replication factor for simple strategy """
+        """ Test equality between passing numeric and string replication factor for NTS """
         rs = ReplicationStrategy()
 
-        simple_int = rs.create('SimpleStrategy', {'replication_factor': 3})
-        simple_str = rs.create('SimpleStrategy', {'replication_factor': '3'})
+        nts_int = rs.create('NetworkTopologyStrategy', {'dc1': 3})
+        nts_str = rs.create('NetworkTopologyStrategy', {'dc1': '3'})
 
-        assert simple_int.export_for_schema() == simple_str.export_for_schema()
-        assert simple_int == simple_str
+        assert nts_int.export_for_schema() == nts_str.export_for_schema()
+        assert nts_int == nts_str
 
         # make token replica map
         ring = [MD5Token(0), MD5Token(1), MD5Token(2)]
-        hosts = [Host('dc1.{}'.format(host), SimpleConvictionPolicy, host_id=uuid.uuid4()) for host in range(3)]
+        hosts = [Host('dc1.{}'.format(host), SimpleConvictionPolicy, datacenter='dc1', rack='rack1', host_id=uuid.uuid4()) for host in range(3)]
         token_to_host = dict(zip(ring, hosts))
-        assert simple_int.make_token_replica_map(token_to_host, ring) == simple_str.make_token_replica_map(token_to_host, ring)
+        assert nts_int.make_token_replica_map(token_to_host, ring) == nts_str.make_token_replica_map(token_to_host, ring)
 
     def test_transient_replication_parsing(self):
-        """ Test that we can PARSE a transient replication factor for SimpleStrategy """
+        """ Test that we can PARSE a transient replication factor for NetworkTopologyStrategy """
         rs = ReplicationStrategy()
 
-        simple_transient = rs.create('SimpleStrategy', {'replication_factor': '3/1'})
-        assert simple_transient.replication_factor_info == ReplicationFactor(3, 1)
-        assert simple_transient.replication_factor == 2
-        assert "'replication_factor': '3/1'" in simple_transient.export_for_schema()
+        nts_transient = rs.create('NetworkTopologyStrategy', {'dc1': '3/1'})
+        assert nts_transient.dc_replication_factors_info['dc1'] == ReplicationFactor(3, 1)
+        assert nts_transient.dc_replication_factors['dc1'] == 2
+        assert "'dc1': '3/1'" in nts_transient.export_for_schema()
 
-        simple_str = rs.create('SimpleStrategy', {'replication_factor': '2'})
-        assert simple_transient != simple_str
+        nts_str = rs.create('NetworkTopologyStrategy', {'dc1': '2'})
+        assert nts_transient != nts_str
 
         # make token replica map
         ring = [MD5Token(0), MD5Token(1), MD5Token(2)]
-        hosts = [Host('dc1.{}'.format(host), SimpleConvictionPolicy, host_id=uuid.uuid4()) for host in range(3)]
+        hosts = [Host('dc1.{}'.format(host), SimpleConvictionPolicy, datacenter='dc1', rack='rack1', host_id=uuid.uuid4()) for host in range(3)]
         token_to_host = dict(zip(ring, hosts))
-        assert simple_transient.make_token_replica_map(token_to_host, ring) == simple_str.make_token_replica_map(token_to_host, ring)
+        assert nts_transient.make_token_replica_map(token_to_host, ring) == nts_str.make_token_replica_map(token_to_host, ring)
 
     def test_nts_replication_parsing(self):
         """ Test equality between passing numeric and string replication factor for NTS """
@@ -318,9 +318,9 @@ def test_nts_export_for_schema(self):
         assert "{'class': 'NetworkTopologyStrategy', 'dc1': '1', 'dc2': '2'}" == strategy.export_for_schema()
 
     def test_simple_strategy_make_token_replica_map(self):
-        host1 = Host('1', SimpleConvictionPolicy, host_id=uuid.uuid4())
-        host2 = Host('2', SimpleConvictionPolicy, host_id=uuid.uuid4())
-        host3 = Host('3', SimpleConvictionPolicy, host_id=uuid.uuid4())
+        host1 = Host('1', SimpleConvictionPolicy, datacenter='dc1', rack='rack1', host_id=uuid.uuid4())
+        host2 = Host('2', SimpleConvictionPolicy, datacenter='dc1', rack='rack1', host_id=uuid.uuid4())
+        host3 = Host('3', SimpleConvictionPolicy, datacenter='dc1', rack='rack1', host_id=uuid.uuid4())
         token_to_host_owner = {
             MD5Token(0): host1,
             MD5Token(100): host2,
@@ -328,23 +328,23 @@ def test_simple_strategy_make_token_replica_map(self):
         }
         ring = [MD5Token(0), MD5Token(100), MD5Token(200)]
 
-        rf1_replicas = SimpleStrategy({'replication_factor': '1'}).make_token_replica_map(token_to_host_owner, ring)
+        rf1_replicas = NetworkTopologyStrategy({'dc1': '1'}).make_token_replica_map(token_to_host_owner, ring)
         assertCountEqual(rf1_replicas[MD5Token(0)], [host1])
         assertCountEqual(rf1_replicas[MD5Token(100)], [host2])
         assertCountEqual(rf1_replicas[MD5Token(200)], [host3])
 
-        rf2_replicas = SimpleStrategy({'replication_factor': '2'}).make_token_replica_map(token_to_host_owner, ring)
+        rf2_replicas = NetworkTopologyStrategy({'dc1': '2'}).make_token_replica_map(token_to_host_owner, ring)
         assertCountEqual(rf2_replicas[MD5Token(0)], [host1, host2])
         assertCountEqual(rf2_replicas[MD5Token(100)], [host2, host3])
         assertCountEqual(rf2_replicas[MD5Token(200)], [host3, host1])
 
-        rf3_replicas = SimpleStrategy({'replication_factor': '3'}).make_token_replica_map(token_to_host_owner, ring)
+        rf3_replicas = NetworkTopologyStrategy({'dc1': '3'}).make_token_replica_map(token_to_host_owner, ring)
         assertCountEqual(rf3_replicas[MD5Token(0)], [host1, host2, host3])
         assertCountEqual(rf3_replicas[MD5Token(100)], [host2, host3, host1])
         assertCountEqual(rf3_replicas[MD5Token(200)], [host3, host1, host2])
 
     def test_ss_equals(self):
-        assert SimpleStrategy({'replication_factor': '1'}) != NetworkTopologyStrategy({'dc1': 2})
+        assert NetworkTopologyStrategy({'dc1': '1'}) != NetworkTopologyStrategy({'dc1': 2})
 
 
 class NameEscapingTest(unittest.TestCase):
@@ -409,9 +409,9 @@ def test_is_valid_name(self):
 class GetReplicasTest(unittest.TestCase):
     def _get_replicas(self, token_klass):
         tokens = [token_klass(i) for i in range(0, (2 ** 127 - 1), 2 ** 125)]
-        hosts = [Host("ip%d" % i, SimpleConvictionPolicy, host_id=uuid.uuid4()) for i in range(len(tokens))]
+        hosts = [Host("ip%d" % i, SimpleConvictionPolicy, datacenter="dc1", rack="rack1", host_id=uuid.uuid4()) for i in range(len(tokens))]
         token_to_primary_replica = dict(zip(tokens, hosts))
-        keyspace = KeyspaceMetadata("ks", True, "SimpleStrategy", {"replication_factor": "1"})
+        keyspace = KeyspaceMetadata("ks", True, "NetworkTopologyStrategy", {"dc1": "1"})
         metadata = Mock(spec=Metadata, keyspaces={'ks': keyspace})
         token_map = TokenMap(token_klass, token_to_primary_replica, tokens, metadata)
 
@@ -524,13 +524,13 @@ class KeyspaceMetadataTest(unittest.TestCase):
 
     def test_export_as_string_user_types(self):
         keyspace_name = 'test'
-        keyspace = KeyspaceMetadata(keyspace_name, True, 'SimpleStrategy', dict(replication_factor=3))
+        keyspace = KeyspaceMetadata(keyspace_name, True, 'NetworkTopologyStrategy', dict(dc1=3))
         keyspace.user_types['a'] = UserType(keyspace_name, 'a', ['one', 'two'], ['c', 'int'])
         keyspace.user_types['b'] = UserType(keyspace_name, 'b', ['one', 'two', 'three'], ['d', 'int', 'a'])
         keyspace.user_types['c'] = UserType(keyspace_name, 'c', ['one'], ['int'])
         keyspace.user_types['d'] = UserType(keyspace_name, 'd', ['one'], ['c'])
 
-        assert """CREATE KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}  AND durable_writes = true;
+        assert """CREATE KEYSPACE test WITH replication = {'class': 'NetworkTopologyStrategy', 'dc1': '3'}  AND durable_writes = true;
 
 CREATE TYPE test.c (
     one int
@@ -662,7 +662,7 @@ class UnicodeIdentifiersTests(unittest.TestCase):
     name = b'\'_-()"\xc2\xac'.decode('utf-8')
 
     def test_keyspace_name(self):
-        km = KeyspaceMetadata(self.name, False, 'SimpleStrategy', {'replication_factor': 1})
+        km = KeyspaceMetadata(self.name, False, 'NetworkTopologyStrategy', {'dc1': 1})
         km.export_as_string()
 
     def test_table_name(self):

From f7d945ff52df0e101c0b15070675cad0500ced11 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 May 2026 12:57:05 +0000
Subject: [PATCH 45/49] build(deps): bump urllib3 from 2.6.3 to 2.7.0 in /docs

Bumps [urllib3](https://github.com/urllib3/urllib3) from 2.6.3 to 2.7.0.
- [Release notes](https://github.com/urllib3/urllib3/releases)
- [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst)
- [Commits](https://github.com/urllib3/urllib3/compare/2.6.3...2.7.0)

---
updated-dependencies:
- dependency-name: urllib3
  dependency-version: 2.7.0
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 docs/uv.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/uv.lock b/docs/uv.lock
index 56b0841403..515e37abba 100644
--- a/docs/uv.lock
+++ b/docs/uv.lock
@@ -1067,11 +1067,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.6.3"
+version = "2.7.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
 ]
 
 [[package]]

From cf01c3f9973388fc6b7ca8425c37deea6ff00a2f Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Fri, 15 May 2026 11:00:26 +0200
Subject: [PATCH 46/49] tests: use tablets-disabled keyspace instead of xfail
 for scylladb/scylladb#22677

Tests that previously xfailed on ScyllaDB < 2026.1 due to MVs, secondary
indexes, and counters not being supported on tables with tablets now create
their keyspace with 'AND tablets = {"enabled": false}' for those older
versions, so the tests run and pass rather than being expected to fail.

A new helper get_tablets_disabled_ddl_suffix() is added to
tests/integration/__init__.py to return the appropriate DDL suffix.
---
 tests/integration/__init__.py                 | 11 ++++
 .../integration/cqlengine/query/test_named.py | 10 +++-
 tests/integration/standard/test_metadata.py   | 60 +++++++++----------
 tests/integration/standard/test_query.py      | 11 +++-
 4 files changed, 55 insertions(+), 37 deletions(-)

diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py
index 7d4d47c9a7..5701e5b3da 100644
--- a/tests/integration/__init__.py
+++ b/tests/integration/__init__.py
@@ -707,6 +707,17 @@ def xfail_scylla_version_lt(reason, scylla_version, *args, **kwargs):
     return pytest.mark.xfail(current_version < Version(scylla_version), reason=reason, *args, **kwargs)
 
 
+def get_tablets_disabled_ddl_suffix(scylla_version='2026.1'):
+    """
+    Returns DDL option string for disabling tablets on ScyllaDB versions older than scylla_version.
+    Used to work around features not yet supported with tablets (e.g. MVs, secondary indexes, counters).
+    :param scylla_version: str, version from which tablets support the feature
+    """
+    if SCYLLA_VERSION is not None and Version(get_scylla_version(SCYLLA_VERSION)) < Version(scylla_version):
+        return " AND tablets = {'enabled': false}"
+    return ""
+
+
 def skip_scylla_version_lt(reason, scylla_version):
     """
     Skip tests on scylla versions older than the specified thresholds.
diff --git a/tests/integration/cqlengine/query/test_named.py b/tests/integration/cqlengine/query/test_named.py
index 4923a8a583..66ba8b973a 100644
--- a/tests/integration/cqlengine/query/test_named.py
+++ b/tests/integration/cqlengine/query/test_named.py
@@ -27,7 +27,7 @@
 from tests.integration.cqlengine.query.test_queryset import BaseQuerySetUsage
 
 
-from tests.integration import BasicSharedKeyspaceUnitTestCase, greaterthanorequalcass30, requires_collection_indexes, xfail_scylla_version_lt
+from tests.integration import BasicSharedKeyspaceUnitTestCase, greaterthanorequalcass30, requires_collection_indexes, get_tablets_disabled_ddl_suffix, execute_with_long_wait_retry
 import pytest
 
 
@@ -280,6 +280,12 @@ def test_get_multipleobjects_exception(self):
 
 class TestNamedWithMV(BasicSharedKeyspaceUnitTestCase):
 
+    @classmethod
+    def create_keyspace(cls, rf):
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}{2}".format(
+            cls.ks_name, rf, get_tablets_disabled_ddl_suffix())
+        execute_with_long_wait_retry(cls.session, ddl)
+
     @classmethod
     def setUpClass(cls):
         super(TestNamedWithMV, cls).setUpClass()
@@ -292,8 +298,6 @@ def tearDownClass(cls):
         super(TestNamedWithMV, cls).tearDownClass()
 
     @greaterthanorequalcass30
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Materialized views and secondary indexes are not supported on base tables with tablets.',
-                             scylla_version='2026.1')
     @execute_count(5)
     def test_named_table_with_mv(self):
         """
diff --git a/tests/integration/standard/test_metadata.py b/tests/integration/standard/test_metadata.py
index 84ec6c9ea5..f5a11dd5fe 100644
--- a/tests/integration/standard/test_metadata.py
+++ b/tests/integration/standard/test_metadata.py
@@ -45,7 +45,7 @@
                                lessthancass40,
                                TestCluster, requires_java_udf, requires_composite_type,
                                requires_collection_indexes, SCYLLA_VERSION, xfail_scylla, xfail_scylla_version_lt,
-                               requirescompactstorage)
+                               requirescompactstorage, get_tablets_disabled_ddl_suffix, execute_with_long_wait_retry)
 
 from tests.util import wait_until, assertRegex, assertDictEqual, assertListEqual, assert_startswith_diff
 
@@ -141,6 +141,12 @@ def test_bad_contact_point(self):
 
 class SchemaMetadataTests(BasicSegregatedKeyspaceUnitTestCase):
 
+    @classmethod
+    def create_keyspace(cls, rf):
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}{2}".format(
+            cls.ks_name, rf, get_tablets_disabled_ddl_suffix())
+        execute_with_long_wait_retry(cls.session, ddl)
+
     def test_schema_metadata_disable(self):
         """
         Checks to ensure that schema metadata_enabled, and token_metadata_enabled
@@ -448,8 +454,6 @@ def test_dense_compact_storage(self):
         tablemeta = self.get_table_metadata()
         self.check_create_statement(tablemeta, create_statement)
 
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Counters are not yet supported with tablets',
-                             scylla_version="2026.1")
     def test_counter(self):
         create_statement = (
             "CREATE TABLE {keyspace}.{table} ("
@@ -724,8 +728,6 @@ def test_refresh_table_metadata(self):
         cluster2.shutdown()
 
     @greaterthanorequalcass30
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_refresh_metadata_for_mv(self):
         """
         test for synchronously refreshing materialized view metadata
@@ -935,8 +937,6 @@ def test_refresh_user_aggregate_metadata(self):
 
     @greaterthanorequalcass30
     @requires_collection_indexes
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_multiple_indices(self):
         """
         test multiple indices on the same column.
@@ -970,8 +970,6 @@ def test_multiple_indices(self):
         assert index_2.keyspace_name == "schemametadatatests"
 
     @greaterthanorequalcass30
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_table_extensions(self):
         s = self.session
         ks = self.keyspace_name
@@ -1204,8 +1202,6 @@ def test_export_keyspace_schema_udts(self):
         cluster.shutdown()
 
     @greaterthancass21
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_case_sensitivity(self):
         """
         Test that names that need to be escaped in CREATE statements are
@@ -1218,10 +1214,9 @@ def test_case_sensitivity(self):
         cfname = 'AnInterestingTable'
 
         session.execute("DROP KEYSPACE IF EXISTS {0}".format(ksname))
-        session.execute("""
-            CREATE KEYSPACE "%s"
-            WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}
-            """ % (ksname,))
+        session.execute(
+            ("CREATE KEYSPACE \"%s\" WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}" +
+             get_tablets_disabled_ddl_suffix()) % (ksname,))
         session.execute("""
             CREATE TABLE "%s"."%s" (
                 k int,
@@ -1442,11 +1437,9 @@ def setup_class(cls):
             if cls.keyspace_name in cls.cluster.metadata.keyspaces:
                 cls.session.execute("DROP KEYSPACE %s" % cls.keyspace_name)
 
-            cls.session.execute(
-                """
-                CREATE KEYSPACE %s
-                WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'};
-                """ % cls.keyspace_name)
+            ddl = ("CREATE KEYSPACE %s WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}" +
+                   get_tablets_disabled_ddl_suffix())
+            cls.session.execute(ddl % cls.keyspace_name)
             cls.session.set_keyspace(cls.keyspace_name)
         except Exception:
             cls.cluster.shutdown()
@@ -1465,8 +1458,6 @@ def create_basic_table(self):
     def drop_basic_table(self):
         self.session.execute("DROP TABLE %s" % self.table_name)
 
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_index_updates(self):
         self.create_basic_table()
 
@@ -1508,8 +1499,6 @@ def test_index_updates(self):
         assert 'a_idx' not in ks_meta.indexes
         assert 'b_idx' not in ks_meta.indexes
 
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_index_follows_alter(self):
         self.create_basic_table()
 
@@ -2019,7 +2008,8 @@ def setup_class(cls):
         cls.cluster = TestCluster()
         cls.keyspace_name = cls.__name__.lower()
         cls.session = cls.cluster.connect()
-        cls.session.execute("CREATE KEYSPACE %s WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}" % cls.keyspace_name)
+        ddl = "CREATE KEYSPACE %s WITH replication = {'class': 'NetworkTopologyStrategy', 'replication_factor': '1'}" + get_tablets_disabled_ddl_suffix()
+        cls.session.execute(ddl % cls.keyspace_name)
         cls.session.set_keyspace(cls.keyspace_name)
         connection = cls.cluster.control_connection._connection
 
@@ -2051,8 +2041,6 @@ def test_bad_table(self):
             assert m._exc_info[0] is self.BadMetaException
             assert "/*\nWarning:" in m.export_as_string()
 
-    @xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
     def test_bad_index(self):
         self.session.execute('CREATE TABLE %s (k int PRIMARY KEY, v int)' % self.function_name)
         self.session.execute('CREATE INDEX ON %s(v)' % self.function_name)
@@ -2144,10 +2132,15 @@ def test_dct_alias(self):
 
 
 @greaterthanorequalcass30
-@xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                         scylla_version="2026.1")
 class MaterializedViewMetadataTestSimple(BasicSharedKeyspaceUnitTestCase):
 
+    @classmethod
+    def create_keyspace(cls, rf):
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}{2}".format(
+            cls.ks_name, rf, get_tablets_disabled_ddl_suffix())
+        execute_with_long_wait_retry(cls.session, ddl)
+
+
     def setUp(self):
         self.session.execute("CREATE TABLE {0}.{1} (pk int PRIMARY KEY, c int)".format(self.keyspace_name, self.function_table_name))
         self.session.execute(
@@ -2234,9 +2227,14 @@ def test_materialized_view_metadata_drop(self):
 
 
 @greaterthanorequalcass30
-@xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Secondary indexes are not supported on base tables with tablets',
-                             scylla_version="2026.1")
 class MaterializedViewMetadataTestComplex(BasicSegregatedKeyspaceUnitTestCase):
+
+    @classmethod
+    def create_keyspace(cls, rf):
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}{2}".format(
+            cls.ks_name, rf, get_tablets_disabled_ddl_suffix())
+        execute_with_long_wait_retry(cls.session, ddl)
+
     def test_create_view_metadata(self):
         """
         test to ensure that materialized view metadata is properly constructed
diff --git a/tests/integration/standard/test_query.py b/tests/integration/standard/test_query.py
index 5ae9242ac0..210f6dacb1 100644
--- a/tests/integration/standard/test_query.py
+++ b/tests/integration/standard/test_query.py
@@ -26,7 +26,8 @@
 from cassandra.policies import HostDistance, RoundRobinPolicy, WhiteListRoundRobinPolicy
 from tests.integration import use_singledc, PROTOCOL_VERSION, BasicSharedKeyspaceUnitTestCase, \
     greaterthanprotocolv3, MockLoggingHandler, get_supported_protocol_versions, local, get_cluster, setup_keyspace, \
-    USE_CASS_EXTERNAL, greaterthanorequalcass40, TestCluster, xfail_scylla, xfail_scylla_version_lt
+    USE_CASS_EXTERNAL, greaterthanorequalcass40, TestCluster, xfail_scylla, xfail_scylla_version_lt, \
+    get_tablets_disabled_ddl_suffix, execute_with_long_wait_retry
 from tests import notwindows
 from tests.integration import greaterthanorequalcass30, get_node
 from tests.util import assertListEqual, wait_until
@@ -1166,10 +1167,14 @@ def test_inherit_first_rk_prepared_param(self):
 
 
 @greaterthanorequalcass30
-@xfail_scylla_version_lt(reason='scylladb/scylladb#22677 - Materialized views and secondary indexes are not supported on base tables with tablets.',
-                         scylla_version='2026.1')
 class MaterializedViewQueryTest(BasicSharedKeyspaceUnitTestCase):
 
+    @classmethod
+    def create_keyspace(cls, rf):
+        ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'NetworkTopologyStrategy', 'replication_factor': '{1}'}}{2}".format(
+            cls.ks_name, rf, get_tablets_disabled_ddl_suffix())
+        execute_with_long_wait_retry(cls.session, ddl)
+
     def test_mv_filtering(self):
         """
         Test to ensure that cql filtering where clauses are properly supported in the python driver.

From a0eb30421c583d2f8985764d096148240c2ed2cc Mon Sep 17 00:00:00 2001
From: Roy Dahan <roy@scylladb.com>
Date: Mon, 11 May 2026 21:10:57 +0300
Subject: [PATCH 47/49] asyncio: fix SSL connections by using native TLS
 transport

Python 3.8+ rejects ssl.SSLSocket in asyncio's sock_sendall/sock_recv
with TypeError. This caused the driver to fail connecting to ScyllaDB
clusters requiring TLS, manifesting as 'protocol version 21 not
supported' errors (0x15 = TLS Alert byte misread as protocol version).

Fix by using asyncio's native TLS transport (loop.create_connection
with ssl= parameter) instead of wrapping sockets with
ssl.SSLContext.wrap_socket(). This preserves shard-aware port binding
done during _initiate_connection().

Add _AsyncioProtocol to bridge asyncio's transport/protocol API back
to Connection.process_io_buffer() for SSL data reads. Non-SSL
connections continue using the existing sock_recv path.

Fixes #330
---
 cassandra/io/asyncioreactor.py | 199 ++++++++++++++++++++++++++++-----
 1 file changed, 168 insertions(+), 31 deletions(-)

diff --git a/cassandra/io/asyncioreactor.py b/cassandra/io/asyncioreactor.py
index 66e1d7295c..452667c8eb 100644
--- a/cassandra/io/asyncioreactor.py
+++ b/cassandra/io/asyncioreactor.py
@@ -23,8 +23,8 @@
     asyncio.run_coroutine_threadsafe
 except AttributeError:
     raise ImportError(
-        'Cannot use asyncioreactor without access to '
-        'asyncio.run_coroutine_threadsafe (added in 3.4.6 and 3.5.1)'
+        "Cannot use asyncioreactor without access to "
+        "asyncio.run_coroutine_threadsafe (added in 3.4.6 and 3.5.1)"
     )
 
 
@@ -38,12 +38,12 @@ class AsyncioTimer(object):
 
     @property
     def end(self):
-        raise NotImplementedError('{} is not compatible with TimerManager and '
-                                  'does not implement .end()')
+        raise NotImplementedError(
+            "{} is not compatible with TimerManager and does not implement .end()"
+        )
 
     def __init__(self, timeout, callback, loop):
-        delayed = self._call_delayed_coro(timeout=timeout,
-                                          callback=callback)
+        delayed = self._call_delayed_coro(timeout=timeout, callback=callback)
         self._handle = asyncio.run_coroutine_threadsafe(delayed, loop=loop)
 
     @staticmethod
@@ -63,17 +63,61 @@ def cancel(self):
     def finish(self):
         # connection.Timer method not implemented here because we can't inspect
         # the Handle returned from call_later
-        raise NotImplementedError('{} is not compatible with TimerManager and '
-                                  'does not implement .finish()')
+        raise NotImplementedError(
+            "{} is not compatible with TimerManager and does not implement .finish()"
+        )
+
+
+class _AsyncioProtocol(asyncio.Protocol):
+    """
+    Protocol adapter for asyncio SSL connections. Bridges asyncio's
+    transport/protocol API back to AsyncioConnection's buffer processing.
+    """
+
+    def __init__(self, connection, loop_args=None):
+        self._connection = connection
+        self.transport = None
+        self.write_ready = asyncio.Event(**(loop_args or {}))
+        self.write_ready.set()
+
+    def connection_made(self, transport):
+        self.transport = transport
+
+    def data_received(self, data):
+        conn = self._connection
+        conn._iobuf.write(data)
+        if conn._iobuf.tell():
+            conn.process_io_buffer()
+
+    def pause_writing(self):
+        self.write_ready.clear()
+
+    def resume_writing(self):
+        self.write_ready.set()
+
+    def connection_lost(self, exc):
+        # Unblock any paused writer so shutdown does not hang
+        self.write_ready.set()
+        conn = self._connection
+        if exc:
+            log.debug("Connection %s lost: %s", conn, exc)
+            conn.defunct(exc)
+        else:
+            log.debug("Connection %s closed by server", conn)
+            conn.close()
+
+    def eof_received(self):
+        return False
 
 
 class AsyncioConnection(Connection):
     """
-    An experimental implementation of :class:`.Connection` that uses the
-    ``asyncio`` module in the Python standard library for its event loop.
+    An implementation of :class:`.Connection` that uses the ``asyncio``
+    module in the Python standard library for its event loop.
 
-    Note that it requires ``asyncio`` features that were only introduced in the
-    3.4 line in 3.4.6, and in the 3.5 line in 3.5.1.
+    Supports SSL connections via asyncio's native TLS transport, which
+    avoids the incompatibility between ``ssl.SSLSocket`` and asyncio's
+    low-level socket methods (``sock_sendall``, ``sock_recv``).
     """
 
     _loop = None
@@ -88,26 +132,109 @@ class AsyncioConnection(Connection):
     def __init__(self, *args, **kwargs):
         Connection.__init__(self, *args, **kwargs)
         self._background_tasks = set()
+        self._transport = None
+        self._using_ssl = bool(self.ssl_context)
 
         self._connect_socket()
         self._socket.setblocking(0)
         loop_args = dict()
         if sys.version_info[0] == 3 and sys.version_info[1] < 10:
-            loop_args['loop'] = self._loop
+            loop_args["loop"] = self._loop
+        self._protocol = _AsyncioProtocol(self, loop_args) if self._using_ssl else None
+        self._ssl_ready = asyncio.Event(**loop_args) if self._using_ssl else None
         self._write_queue = asyncio.Queue(**loop_args)
         self._write_queue_lock = asyncio.Lock(**loop_args)
 
         # see initialize_reactor -- loop is running in a separate thread, so we
         # have to use a threadsafe call
-        self._read_watcher = asyncio.run_coroutine_threadsafe(
-            self.handle_read(), loop=self._loop
-        )
+        if self._using_ssl:
+            # For SSL: set up asyncio transport/protocol, then start writer
+            self._read_watcher = asyncio.run_coroutine_threadsafe(
+                self._setup_ssl_and_run(), loop=self._loop
+            )
+        else:
+            # For non-SSL: use low-level sock_sendall/sock_recv as before
+            self._read_watcher = asyncio.run_coroutine_threadsafe(
+                self.handle_read(), loop=self._loop
+            )
         self._write_watcher = asyncio.run_coroutine_threadsafe(
             self.handle_write(), loop=self._loop
         )
         self._send_options_message()
 
+    def _connect_socket(self):
+        """
+        Override base class to skip SSL wrapping of the socket.
+        For SSL connections, the plain TCP socket is connected here, and TLS
+        is set up later via asyncio's native SSL transport in _setup_ssl_and_run().
+        """
+        sockerr = None
+        addresses = self._get_socket_addresses()
+        for af, socktype, proto, _, sockaddr in addresses:
+            try:
+                self._socket = self._socket_impl.socket(af, socktype, proto)
+                # Do NOT wrap with ssl_context here -- asyncio will handle TLS
+                self._socket.settimeout(self.connect_timeout)
+                self._initiate_connection(sockaddr)
+                self._socket.settimeout(None)
+
+                local_addr = self._socket.getsockname()
+                log.debug("Connection %s: '%s' -> '%s'", id(self), local_addr, sockaddr)
+                sockerr = None
+                break
+            except socket.error as err:
+                if self._socket:
+                    self._socket.close()
+                    self._socket = None
+                sockerr = err
+
+        if sockerr:
+            raise socket.error(
+                sockerr.errno,
+                "Tried connecting to %s. Last error: %s"
+                % ([a[4] for a in addresses], sockerr.strerror or sockerr),
+            )
+
+        if self.sockopts:
+            for args in self.sockopts:
+                self._socket.setsockopt(*args)
+
+    async def _setup_ssl_and_run(self):
+        """
+        Upgrade the plain TCP connection to TLS using asyncio's native SSL
+        transport, then continuously read data via the protocol callbacks.
+        """
+        try:
+            ssl_context = self.ssl_context
+            server_hostname = None
+            if self.ssl_options:
+                server_hostname = self.ssl_options.get("server_hostname", None)
+            if server_hostname is None:
+                # asyncio's create_connection requires server_hostname when
+                # ssl= is set. Use endpoint address for SNI/verification when
+                # check_hostname is enabled; otherwise pass "" to suppress SNI.
+                server_hostname = (
+                    self.endpoint.address if ssl_context.check_hostname else ""
+                )
+
+            transport, protocol = await self._loop.create_connection(
+                lambda: self._protocol,
+                sock=self._socket,
+                ssl=ssl_context,
+                server_hostname=server_hostname,
+            )
+            self._transport = transport
+
+            if self._check_hostname:
+                self._validate_hostname()
 
+            self._ssl_ready.set()
+        except Exception as exc:
+            log.debug("SSL setup failed for %s: %s", self, exc)
+            self.defunct(exc)
+            # Unblock handle_write so it can observe the defunct state and exit
+            self._ssl_ready.set()
+            return
 
     @classmethod
     def initialize_reactor(cls):
@@ -126,8 +253,9 @@ def initialize_reactor(cls):
                 cls._loop = asyncio.new_event_loop()
                 # daemonize so the loop will be shut down on interpreter
                 # shutdown
-                cls._loop_thread = Thread(target=cls._loop.run_forever,
-                                          daemon=True, name="asyncio_thread")
+                cls._loop_thread = Thread(
+                    target=cls._loop.run_forever, daemon=True, name="asyncio_thread"
+                )
                 cls._loop_thread.start()
 
     @classmethod
@@ -142,9 +270,7 @@ def close(self):
 
         # close from the loop thread to avoid races when removing file
         # descriptors
-        asyncio.run_coroutine_threadsafe(
-            self._close(), loop=self._loop
-        )
+        asyncio.run_coroutine_threadsafe(self._close(), loop=self._loop)
 
     async def _close(self):
         log.debug("Closing connection (%s) to %s" % (id(self), self.endpoint))
@@ -152,7 +278,10 @@ async def _close(self):
             self._write_watcher.cancel()
         if self._read_watcher:
             self._read_watcher.cancel()
-        if self._socket:
+        if self._transport:
+            self._transport.close()
+            self._transport = None
+        elif self._socket:
             self._loop.remove_writer(self._socket.fileno())
             self._loop.remove_reader(self._socket.fileno())
             self._socket.close()
@@ -172,15 +301,12 @@ def push(self, data):
         if len(data) > buff_size:
             chunks = []
             for i in range(0, len(data), buff_size):
-                chunks.append(data[i:i + buff_size])
+                chunks.append(data[i : i + buff_size])
         else:
             chunks = [data]
 
         if self._loop_thread != threading.current_thread():
-            asyncio.run_coroutine_threadsafe(
-                self._push_msg(chunks),
-                loop=self._loop
-            )
+            asyncio.run_coroutine_threadsafe(self._push_msg(chunks), loop=self._loop)
         else:
             # avoid races/hangs by just scheduling this, not using threadsafe
             task = self._loop.create_task(self._push_msg(chunks))
@@ -194,13 +320,25 @@ async def _push_msg(self, chunks):
             for chunk in chunks:
                 self._write_queue.put_nowait(chunk)
 
-
     async def handle_write(self):
+        # For SSL connections, wait until the TLS handshake completes
+        if self._ssl_ready:
+            await self._ssl_ready.wait()
+            if self.is_defunct:
+                return
         while True:
             try:
                 next_msg = await self._write_queue.get()
                 if next_msg:
-                    await self._loop.sock_sendall(self._socket, next_msg)
+                    if self._transport:
+                        # SSL: use asyncio transport (handles TLS transparently)
+                        await self._protocol.write_ready.wait()
+                        if self.is_closed or self.is_defunct or not self._transport:
+                            return
+                        self._transport.write(next_msg)
+                    else:
+                        # Non-SSL: use low-level socket API
+                        await self._loop.sock_sendall(self._socket, next_msg)
             except socket.error as err:
                 log.debug("Exception in send for %s: %s", self, err)
                 self.defunct(err)
@@ -223,8 +361,7 @@ async def handle_read(self):
                 await asyncio.sleep(0)
                 continue
             except socket.error as err:
-                log.debug("Exception during socket recv for %s: %s",
-                          self, err)
+                log.debug("Exception during socket recv for %s: %s", self, err)
                 self.defunct(err)
                 return  # leave the read loop
             except asyncio.CancelledError:

From 44bc95ad6cb66f836fc501cb045bb5fdf95643ba Mon Sep 17 00:00:00 2001
From: sylwiaszunejko <sylwia.szunejko@gmail.com>
Date: Thu, 21 May 2026 11:24:40 +0200
Subject: [PATCH 48/49] Pin GitHub Actions to commit hashes and enforce pinning

- Update all action references to use full SHA commit hashes
- Configure Renovate to pin digests and require 90-day minimum age
- Add github-actions ecosystem to Dependabot
---
 .github/workflows/build-push.yml        |  4 ++--
 .github/workflows/call_jira_sync.yml    |  2 +-
 .github/workflows/docs-pages.yml        |  4 ++--
 .github/workflows/docs-pr.yml           |  4 ++--
 .github/workflows/integration-tests.yml |  8 ++++----
 .github/workflows/lib-build.yml         | 16 ++++++++--------
 .github/workflows/publish-manually.yml  |  4 ++--
 renovate.json                           |  7 +++++++
 8 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/.github/workflows/build-push.yml b/.github/workflows/build-push.yml
index 3a3d93171a..a1a6c854c7 100644
--- a/.github/workflows/build-push.yml
+++ b/.github/workflows/build-push.yml
@@ -24,11 +24,11 @@ jobs:
     permissions:
       id-token: write
     steps:
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           path: dist
           merge-multiple: true
 
-      - uses: pypa/gh-action-pypi-publish@release/v1
+      - uses: pypa/gh-action-pypi-publish@cef2210092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
         with:
           skip-existing: true
diff --git a/.github/workflows/call_jira_sync.yml b/.github/workflows/call_jira_sync.yml
index 14f517df40..0855246f48 100644
--- a/.github/workflows/call_jira_sync.yml
+++ b/.github/workflows/call_jira_sync.yml
@@ -11,7 +11,7 @@ permissions:
 
 jobs:
   jira-sync:
-    uses: scylladb/github-automation/.github/workflows/main_pr_events_jira_sync.yml@main
+    uses: scylladb/github-automation/.github/workflows/main_pr_events_jira_sync.yml@83115dc2553dbf968e73271e97fc7aac16b8145a # main 2026-05-20
     with:
       caller_action: ${{ github.event.action }}
     secrets:
diff --git a/.github/workflows/docs-pages.yml b/.github/workflows/docs-pages.yml
index 9d14b9c4d8..a413e3317e 100644
--- a/.github/workflows/docs-pages.yml
+++ b/.github/workflows/docs-pages.yml
@@ -24,14 +24,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ github.event.repository.default_branch }}
           persist-credentials: false
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.1.0
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           working-directory: docs
           enable-cache: true
diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index f0aa64d628..1881c227ed 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -31,13 +31,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
           fetch-depth: 0
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.1.0
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           working-directory: docs
           enable-cache: true
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 61261aadf8..5e76d6bbb4 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -56,10 +56,10 @@ jobs:
             event_loop_manager: "asyncore"
 
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
     - name: Set up JDK ${{ matrix.java-version }}
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
       with:
         java-version: ${{ matrix.java-version }}
         distribution: 'adopt'
@@ -68,7 +68,7 @@ jobs:
       run: sudo apt-get install libev4 libev-dev
 
     - name: Install uv
-      uses: astral-sh/setup-uv@v8.1.0
+      uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -78,7 +78,7 @@ jobs:
       run: uv sync
 
     - name: Cache Scylla download
-      uses: actions/cache@v5
+      uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
       with:
         path: ~/.ccm/repository
         key: scylla-${{ env.SCYLLA_VERSION }}-${{ runner.os }}
diff --git a/.github/workflows/lib-build.yml b/.github/workflows/lib-build.yml
index 21dcc0604f..04da6cfca5 100644
--- a/.github/workflows/lib-build.yml
+++ b/.github/workflows/lib-build.yml
@@ -77,11 +77,11 @@ jobs:
         include: ${{ fromJson(needs.prepare-matrix.outputs.matrix) }}
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Checkout tag ${{ inputs.target_tag }}
         if: inputs.target_tag != ''
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           ref: ${{ inputs.target_tag }}
 
@@ -96,7 +96,7 @@ jobs:
           echo "CIBW_BEFORE_TEST_WINDOWS=(exit 0)" >> $GITHUB_ENV;
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.1.0
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           python-version: ${{ inputs.python-version }}
 
@@ -111,7 +111,7 @@ jobs:
 
       - name: Install Conan
         if: runner.os == 'Windows'
-        uses: turtlebrowser/get-conan@main
+        uses: turtlebrowser/get-conan@e41c1e039be765c0ed9d9d38cc2a287566e1d8b3 # v1.2
 
       - name: Configure libev for Windows
         if: runner.os == 'Windows'
@@ -147,7 +147,7 @@ jobs:
         run: |
           CIBW_BUILD="cp3*" cibuildwheel --archs aarch64 --output-dir wheelhouse
 
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: wheels-${{ matrix.target }}-${{ matrix.os }}
           path: ./wheelhouse/*.whl
@@ -156,17 +156,17 @@ jobs:
     name: Build source distribution
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.1.0
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
         with:
           python-version: ${{ inputs.python-version }}
 
       - name: Build sdist
         run: uv build --sdist
 
-      - uses: actions/upload-artifact@v7
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
           name: source-dist
           path: dist/*.tar.gz
diff --git a/.github/workflows/publish-manually.yml b/.github/workflows/publish-manually.yml
index 2f15c6ecda..5b9298fb7f 100644
--- a/.github/workflows/publish-manually.yml
+++ b/.github/workflows/publish-manually.yml
@@ -58,11 +58,11 @@ jobs:
     permissions:
       id-token: write
     steps:
-      - uses: actions/download-artifact@v8
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           path: dist
           merge-multiple: true
 
-      - uses: pypa/gh-action-pypi-publish@release/v1
+      - uses: pypa/gh-action-pypi-publish@cef2210092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
         with:
           skip-existing: true
diff --git a/renovate.json b/renovate.json
index 5db72dd6a9..d85ac38c01 100644
--- a/renovate.json
+++ b/renovate.json
@@ -2,5 +2,12 @@
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": [
     "config:recommended"
+  ],
+  "packageRules": [
+    {
+      "matchManagers": ["github-actions"],
+      "pinDigests": true,
+      "minimumReleaseAge": "90 days"
+    }
   ]
 }

From 037118e77ffaf82953bebc035f27ea6a533235a1 Mon Sep 17 00:00:00 2001
From: "renovate[bot]" <29139614+renovate[bot]@users.noreply.github.com>
Date: Fri, 22 May 2026 09:18:40 +0000
Subject: [PATCH 49/49] chore(deps): update turtlebrowser/get-conan digest to
 c171f29

---
 .github/workflows/lib-build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/lib-build.yml b/.github/workflows/lib-build.yml
index 04da6cfca5..f6959ddfec 100644
--- a/.github/workflows/lib-build.yml
+++ b/.github/workflows/lib-build.yml
@@ -111,7 +111,7 @@ jobs:
 
       - name: Install Conan
         if: runner.os == 'Windows'
-        uses: turtlebrowser/get-conan@e41c1e039be765c0ed9d9d38cc2a287566e1d8b3 # v1.2
+        uses: turtlebrowser/get-conan@c171f295f3f507360ee018736a6608731aa2109d # v1.2
 
       - name: Configure libev for Windows
         if: runner.os == 'Windows'