From d0d9b48a9c8ba6e56832c02034b5def53e21c4f2 Mon Sep 17 00:00:00 2001 From: Iris Date: Thu, 8 Oct 2026 13:37:01 -0700 Subject: [PATCH 1/5] wip --- pymongo/asynchronous/mongo_client.py | 113 +---------------------- pymongo/mongo_client_shared.py | 129 ++++++++++++++++++++++++++- pymongo/synchronous/mongo_client.py | 113 +---------------------- 3 files changed, 132 insertions(+), 223 deletions(-) diff --git a/pymongo/asynchronous/mongo_client.py b/pymongo/asynchronous/mongo_client.py index df390a218e..fee6123920 100644 --- a/pymongo/asynchronous/mongo_client.py +++ b/pymongo/asynchronous/mongo_client.py @@ -56,7 +56,6 @@ from bson.codec_options import DEFAULT_CODEC_OPTIONS, CodecOptions, TypeRegistry from bson.timestamp import Timestamp from pymongo import _csot, _op_id, common, helpers_shared, periodic_executor -from pymongo._telemetry import _generate_op_id_or_none, log_command_retry from pymongo.asynchronous import client_session, database, uri_parser from pymongo.asynchronous.change_stream import AsyncChangeStream, AsyncClusterChangeStream from pymongo.asynchronous.client_bulk import _AsyncClientBulk @@ -88,6 +87,7 @@ from pymongo.mongo_client_shared import ( _add_retryable_write_error, _after_fork_child, + _AgnosticClientConnectionRetryableBase, _detect_external_db, ) from pymongo.monitoring import ConnectionClosedReason, _EventListeners @@ -2866,77 +2866,9 @@ async def __aenter__(self) -> tuple[AsyncConnection, _ServerMode]: # type: igno return conn, read_pref -class _ClientConnectionRetryable(Generic[T]): +class _ClientConnectionRetryable(_AgnosticClientConnectionRetryableBase, Generic[T]): """Responsible for executing retryable connections on read or write operations""" - __slots__ = ( - "_address", - "_always_retryable", - "_attempt_number", - "_base_backoff_ms", - "_bulk", - "_client", - "_deprioritized_servers", - "_func", - "_is_aggregate_write", - "_is_read", - "_is_run_command", - "_last_error", - "_max_retries", - "_operation", - "_operation_id", - "_read_pref", - "_retry_policy", - "_retryable", - "_retrying", - "_server", - "_server_selector", - "_session", - ) - - def __init__( - self, - mongo_client: AsyncMongoClient, # type: ignore[type-arg] - func: _WriteCall[T] | _ReadCall[T], - bulk: Optional[Union[_AsyncBulk, _AsyncClientBulk]], - operation: str, - is_read: bool = False, - session: Optional[AsyncClientSession] = None, - read_pref: Optional[_ServerMode] = None, - address: Optional[_Address] = None, - retryable: bool = False, - operation_id: Optional[int] = None, - is_run_command: bool = False, - is_aggregate_write: bool = False, - ): - self._last_error: Optional[Exception] = None - self._retrying = False - self._always_retryable = False - self._max_retries = float("inf") if _csot.get_timeout() is not None else 1 - self._client = mongo_client - self._retry_policy = mongo_client._retry_policy - self._func = func - self._bulk = bulk - self._session = session - self._is_read = is_read - self._retryable = retryable - self._read_pref = read_pref - self._server_selector: Callable[[Selection], Selection] = ( - read_pref if is_read else writable_server_selector # type: ignore - ) - self._address = address - self._server: Server = None # type: ignore - self._deprioritized_servers: Optional[list[Server]] = None - self._operation = operation - # Only generate an operation id when APM/logging is enabled. - if operation_id is None: - operation_id = _generate_op_id_or_none(self._client._event_listeners) - self._operation_id = operation_id - self._attempt_number = 0 - self._is_run_command = is_run_command - self._is_aggregate_write = is_aggregate_write - self._base_backoff_ms: Optional[float] = None - async def run(self) -> T: """Runs the supplied func() and attempts a retry @@ -3091,38 +3023,6 @@ async def run(self) -> T: raise await asyncio.sleep(delay) - def _is_not_eligible_for_retry(self) -> bool: - """Checks if the exchange is not eligible for retry""" - return not self._retryable or ( - self._is_retrying() and self._attempt_number >= self._max_retries - ) - - def _is_retrying(self) -> bool: - """Checks if the exchange is currently undergoing a retry""" - return self._bulk.retrying if self._bulk else self._retrying - - def _is_session_state_retryable(self) -> bool: - """Checks if provided session is eligible for retry - - reads: Make sure there is no ongoing transaction (if provided a session) - writes: Make sure there is a session without an active transaction - """ - if self._is_read: - return not (self._session and self._session.in_transaction) - return bool(self._session and not self._session.in_transaction) - - def _check_last_error(self, check_csot: bool = False) -> None: - """Checks if the ongoing client exchange experienced a exception previously. - If so, raise last error - - :param check_csot: Checks CSOT to ensure we are retrying with time remaining defaults to False - """ - if self._is_retrying(): - remaining = _csot.remaining() - if not check_csot or (remaining is not None and remaining <= 0): - assert self._last_error is not None - raise self._last_error - async def _get_server(self) -> Server: """Retrieves a server object based on provided object context @@ -3137,15 +3037,6 @@ async def _get_server(self) -> Server: operation_id=self._operation_id, ) - def _log_retry(self, is_write: bool) -> None: - log_command_retry( - self._client._topology_id, - self._operation, - self._operation_id, - self._attempt_number, - is_write, - ) - async def _write(self) -> T: """Wrapper method for write-type retryable client executions diff --git a/pymongo/mongo_client_shared.py b/pymongo/mongo_client_shared.py index 29a3db6e7e..d649e36967 100644 --- a/pymongo/mongo_client_shared.py +++ b/pymongo/mongo_client_shared.py @@ -17,8 +17,10 @@ from __future__ import annotations from collections.abc import Mapping -from typing import Any, Optional, cast +from typing import Any, Callable, Generic, Optional, TypeVar, Union, cast +from pymongo import _csot +from pymongo._telemetry import _generate_op_id_or_none, log_command_retry from pymongo.errors import ( BulkWriteError, ClientBulkWriteException, @@ -33,6 +35,18 @@ _CLIENT_LOGGER, _log_or_warn, ) +from pymongo.read_preferences import _ServerMode +from pymongo.server_selectors import Selection, writable_server_selector +from pymongo.typings import ( + _Address, + _AgnosticBulk, + _AgnosticClientBulk, + _AgnosticClientSession, + _AgnosticMongoClient, + _AgnosticServer, +) + +T = TypeVar("T") def _retryable_error_doc(exc: PyMongoError) -> Optional[Mapping[str, Any]]: @@ -109,3 +123,116 @@ def _detect_external_db(entity: str) -> bool: ) return True return False + + +class _AgnosticClientConnectionRetryableBase(Generic[T]): + """Responsible for executing retryable connections on read or write operations""" + + __slots__ = ( + "_address", + "_always_retryable", + "_attempt_number", + "_base_backoff_ms", + "_bulk", + "_client", + "_deprioritized_servers", + "_func", + "_is_aggregate_write", + "_is_read", + "_is_run_command", + "_last_error", + "_max_retries", + "_operation", + "_operation_id", + "_read_pref", + "_retry_policy", + "_retryable", + "_retrying", + "_server", + "_server_selector", + "_session", + ) + + def __init__( + self, + mongo_client: _AgnosticMongoClient, # type: ignore[type-arg] + func: _WriteCall[T] | _ReadCall[T], + bulk: Optional[Union[_AgnosticBulk, _AgnosticClientBulk]], + operation: str, + is_read: bool = False, + session: Optional[_AgnosticClientSession] = None, + read_pref: Optional[_ServerMode] = None, + address: Optional[_Address] = None, + retryable: bool = False, + operation_id: Optional[int] = None, + is_run_command: bool = False, + is_aggregate_write: bool = False, + ): + self._last_error: Optional[Exception] = None + self._retrying = False + self._always_retryable = False + self._max_retries = float("inf") if _csot.get_timeout() is not None else 1 + self._client = mongo_client + self._retry_policy = mongo_client._retry_policy + self._func = func + self._bulk = bulk + self._session = session + self._is_read = is_read + self._retryable = retryable + self._read_pref = read_pref + self._server_selector: Callable[[Selection], Selection] = ( + read_pref if is_read else writable_server_selector # type: ignore + ) + self._address = address + self._server: _AgnosticServer = None # type: ignore + self._deprioritized_servers: Optional[list[_AgnosticServer]] = None + self._operation = operation + # Only generate an operation id when APM/logging is enabled. + if operation_id is None: + operation_id = _generate_op_id_or_none(self._client._event_listeners) + self._operation_id = operation_id + self._attempt_number = 0 + self._is_run_command = is_run_command + self._is_aggregate_write = is_aggregate_write + self._base_backoff_ms: Optional[float] = None + + def _is_not_eligible_for_retry(self) -> bool: + """Checks if the exchange is not eligible for retry""" + return not self._retryable or ( + self._is_retrying() and self._attempt_number >= self._max_retries + ) + + def _is_retrying(self) -> bool: + """Checks if the exchange is currently undergoing a retry""" + return self._bulk.retrying if self._bulk else self._retrying + + def _is_session_state_retryable(self) -> bool: + """Checks if provided session is eligible for retry + + reads: Make sure there is no ongoing transaction (if provided a session) + writes: Make sure there is a session without an active transaction + """ + if self._is_read: + return not (self._session and self._session.in_transaction) + return bool(self._session and not self._session.in_transaction) + + def _check_last_error(self, check_csot: bool = False) -> None: + """Checks if the ongoing client exchange experienced a exception previously. + If so, raise last error + + :param check_csot: Checks CSOT to ensure we are retrying with time remaining defaults to False + """ + if self._is_retrying(): + remaining = _csot.remaining() + if not check_csot or (remaining is not None and remaining <= 0): + assert self._last_error is not None + raise self._last_error + + def _log_retry(self, is_write: bool) -> None: + log_command_retry( + self._client._topology_id, + self._operation, + self._operation_id, + self._attempt_number, + is_write, + ) diff --git a/pymongo/synchronous/mongo_client.py b/pymongo/synchronous/mongo_client.py index 6aaaaed20a..6f49337329 100644 --- a/pymongo/synchronous/mongo_client.py +++ b/pymongo/synchronous/mongo_client.py @@ -56,7 +56,6 @@ from bson.codec_options import DEFAULT_CODEC_OPTIONS, CodecOptions, TypeRegistry from bson.timestamp import Timestamp from pymongo import _csot, _op_id, common, helpers_shared, periodic_executor -from pymongo._telemetry import _generate_op_id_or_none, log_command_retry from pymongo.client_options import ClientOptions from pymongo.client_session_shared import SessionOptions, TransactionOptions, _EmptyServerSession from pymongo.driver_info import DriverInfo @@ -81,6 +80,7 @@ from pymongo.mongo_client_shared import ( _add_retryable_write_error, _after_fork_child, + _AgnosticClientConnectionRetryableBase, _detect_external_db, ) from pymongo.monitoring import ConnectionClosedReason, _EventListeners @@ -2855,77 +2855,9 @@ def __enter__(self) -> tuple[Connection, _ServerMode]: # type: ignore[override] return conn, read_pref -class _ClientConnectionRetryable(Generic[T]): +class _ClientConnectionRetryable(_AgnosticClientConnectionRetryableBase, Generic[T]): """Responsible for executing retryable connections on read or write operations""" - __slots__ = ( - "_address", - "_always_retryable", - "_attempt_number", - "_base_backoff_ms", - "_bulk", - "_client", - "_deprioritized_servers", - "_func", - "_is_aggregate_write", - "_is_read", - "_is_run_command", - "_last_error", - "_max_retries", - "_operation", - "_operation_id", - "_read_pref", - "_retry_policy", - "_retryable", - "_retrying", - "_server", - "_server_selector", - "_session", - ) - - def __init__( - self, - mongo_client: MongoClient, # type: ignore[type-arg] - func: _WriteCall[T] | _ReadCall[T], - bulk: Optional[Union[_Bulk, _ClientBulk]], - operation: str, - is_read: bool = False, - session: Optional[ClientSession] = None, - read_pref: Optional[_ServerMode] = None, - address: Optional[_Address] = None, - retryable: bool = False, - operation_id: Optional[int] = None, - is_run_command: bool = False, - is_aggregate_write: bool = False, - ): - self._last_error: Optional[Exception] = None - self._retrying = False - self._always_retryable = False - self._max_retries = float("inf") if _csot.get_timeout() is not None else 1 - self._client = mongo_client - self._retry_policy = mongo_client._retry_policy - self._func = func - self._bulk = bulk - self._session = session - self._is_read = is_read - self._retryable = retryable - self._read_pref = read_pref - self._server_selector: Callable[[Selection], Selection] = ( - read_pref if is_read else writable_server_selector # type: ignore - ) - self._address = address - self._server: Server = None # type: ignore - self._deprioritized_servers: Optional[list[Server]] = None - self._operation = operation - # Only generate an operation id when APM/logging is enabled. - if operation_id is None: - operation_id = _generate_op_id_or_none(self._client._event_listeners) - self._operation_id = operation_id - self._attempt_number = 0 - self._is_run_command = is_run_command - self._is_aggregate_write = is_aggregate_write - self._base_backoff_ms: Optional[float] = None - def run(self) -> T: """Runs the supplied func() and attempts a retry @@ -3080,38 +3012,6 @@ def run(self) -> T: raise time.sleep(delay) - def _is_not_eligible_for_retry(self) -> bool: - """Checks if the exchange is not eligible for retry""" - return not self._retryable or ( - self._is_retrying() and self._attempt_number >= self._max_retries - ) - - def _is_retrying(self) -> bool: - """Checks if the exchange is currently undergoing a retry""" - return self._bulk.retrying if self._bulk else self._retrying - - def _is_session_state_retryable(self) -> bool: - """Checks if provided session is eligible for retry - - reads: Make sure there is no ongoing transaction (if provided a session) - writes: Make sure there is a session without an active transaction - """ - if self._is_read: - return not (self._session and self._session.in_transaction) - return bool(self._session and not self._session.in_transaction) - - def _check_last_error(self, check_csot: bool = False) -> None: - """Checks if the ongoing client exchange experienced a exception previously. - If so, raise last error - - :param check_csot: Checks CSOT to ensure we are retrying with time remaining defaults to False - """ - if self._is_retrying(): - remaining = _csot.remaining() - if not check_csot or (remaining is not None and remaining <= 0): - assert self._last_error is not None - raise self._last_error - def _get_server(self) -> Server: """Retrieves a server object based on provided object context @@ -3126,15 +3026,6 @@ def _get_server(self) -> Server: operation_id=self._operation_id, ) - def _log_retry(self, is_write: bool) -> None: - log_command_retry( - self._client._topology_id, - self._operation, - self._operation_id, - self._attempt_number, - is_write, - ) - def _write(self) -> T: """Wrapper method for write-type retryable client executions From 549b34679360672d5b3b85b1010eeb013efd409f Mon Sep 17 00:00:00 2001 From: Iris Date: Tue, 3 Nov 2026 17:12:44 -0800 Subject: [PATCH 2/5] PYTHON-6028 Consolidate non-IO code in _ClientConnectionRetryable into shared base class --- pymongo/asynchronous/mongo_client.py | 7 ++++++- pymongo/mongo_client_shared.py | 14 ++++++++------ pymongo/synchronous/mongo_client.py | 7 ++++++- 3 files changed, 20 insertions(+), 8 deletions(-) diff --git a/pymongo/asynchronous/mongo_client.py b/pymongo/asynchronous/mongo_client.py index fee6123920..5ff0f12ce2 100644 --- a/pymongo/asynchronous/mongo_client.py +++ b/pymongo/asynchronous/mongo_client.py @@ -2866,9 +2866,14 @@ async def __aenter__(self) -> tuple[AsyncConnection, _ServerMode]: # type: igno return conn, read_pref -class _ClientConnectionRetryable(_AgnosticClientConnectionRetryableBase, Generic[T]): +class _ClientConnectionRetryable( + _AgnosticClientConnectionRetryableBase[T, "Server", _WriteCall[T] | _ReadCall[T]], Generic[T] +): """Responsible for executing retryable connections on read or write operations""" + _client: AsyncMongoClient[Any] + _session: Optional[AsyncClientSession] + async def run(self) -> T: """Runs the supplied func() and attempts a retry diff --git a/pymongo/mongo_client_shared.py b/pymongo/mongo_client_shared.py index d649e36967..2e90609a7f 100644 --- a/pymongo/mongo_client_shared.py +++ b/pymongo/mongo_client_shared.py @@ -47,6 +47,8 @@ ) T = TypeVar("T") +_ServerT = TypeVar("_ServerT", bound="_AgnosticServer") +_FuncT = TypeVar("_FuncT", bound=Callable[..., Any]) def _retryable_error_doc(exc: PyMongoError) -> Optional[Mapping[str, Any]]: @@ -125,7 +127,7 @@ def _detect_external_db(entity: str) -> bool: return False -class _AgnosticClientConnectionRetryableBase(Generic[T]): +class _AgnosticClientConnectionRetryableBase(Generic[T, _ServerT, _FuncT]): """Responsible for executing retryable connections on read or write operations""" __slots__ = ( @@ -155,8 +157,8 @@ class _AgnosticClientConnectionRetryableBase(Generic[T]): def __init__( self, - mongo_client: _AgnosticMongoClient, # type: ignore[type-arg] - func: _WriteCall[T] | _ReadCall[T], + mongo_client: _AgnosticMongoClient, + func: _FuncT, bulk: Optional[Union[_AgnosticBulk, _AgnosticClientBulk]], operation: str, is_read: bool = False, @@ -174,7 +176,7 @@ def __init__( self._max_retries = float("inf") if _csot.get_timeout() is not None else 1 self._client = mongo_client self._retry_policy = mongo_client._retry_policy - self._func = func + self._func: _FuncT = func self._bulk = bulk self._session = session self._is_read = is_read @@ -184,8 +186,8 @@ def __init__( read_pref if is_read else writable_server_selector # type: ignore ) self._address = address - self._server: _AgnosticServer = None # type: ignore - self._deprioritized_servers: Optional[list[_AgnosticServer]] = None + self._server: _ServerT = None # type: ignore + self._deprioritized_servers: Optional[list[_ServerT]] = None self._operation = operation # Only generate an operation id when APM/logging is enabled. if operation_id is None: diff --git a/pymongo/synchronous/mongo_client.py b/pymongo/synchronous/mongo_client.py index 6f49337329..6ae48f0262 100644 --- a/pymongo/synchronous/mongo_client.py +++ b/pymongo/synchronous/mongo_client.py @@ -2855,9 +2855,14 @@ def __enter__(self) -> tuple[Connection, _ServerMode]: # type: ignore[override] return conn, read_pref -class _ClientConnectionRetryable(_AgnosticClientConnectionRetryableBase, Generic[T]): +class _ClientConnectionRetryable( + _AgnosticClientConnectionRetryableBase[T, "Server", _WriteCall[T] | _ReadCall[T]], Generic[T] +): """Responsible for executing retryable connections on read or write operations""" + _client: MongoClient[Any] + _session: Optional[ClientSession] + def run(self) -> T: """Runs the supplied func() and attempts a retry From 485777eec45605f5fe89f00a79fe03dc0835380b Mon Sep 17 00:00:00 2001 From: Iris Date: Wed, 4 Nov 2026 11:29:31 -0800 Subject: [PATCH 3/5] clean up typing and imports --- drivers-evergreen-tools | 2 +- pymongo/asynchronous/mongo_client.py | 2 +- pymongo/mongo_client_shared.py | 25 ++++++++++++++----------- pymongo/synchronous/mongo_client.py | 2 +- 4 files changed, 17 insertions(+), 14 deletions(-) diff --git a/drivers-evergreen-tools b/drivers-evergreen-tools index e35ecc9d56..354a81692b 160000 --- a/drivers-evergreen-tools +++ b/drivers-evergreen-tools @@ -1 +1 @@ -Subproject commit e35ecc9d563b5dada8185e64b7a571541000bc6d +Subproject commit 354a81692bfd2b654a38277b681d248507d17800 diff --git a/pymongo/asynchronous/mongo_client.py b/pymongo/asynchronous/mongo_client.py index 5ff0f12ce2..49a08a79a6 100644 --- a/pymongo/asynchronous/mongo_client.py +++ b/pymongo/asynchronous/mongo_client.py @@ -2867,7 +2867,7 @@ async def __aenter__(self) -> tuple[AsyncConnection, _ServerMode]: # type: igno class _ClientConnectionRetryable( - _AgnosticClientConnectionRetryableBase[T, "Server", _WriteCall[T] | _ReadCall[T]], Generic[T] + _AgnosticClientConnectionRetryableBase[T, "Server", _WriteCall[T] | _ReadCall[T]] ): """Responsible for executing retryable connections on read or write operations""" diff --git a/pymongo/mongo_client_shared.py b/pymongo/mongo_client_shared.py index 2e90609a7f..2951af5db1 100644 --- a/pymongo/mongo_client_shared.py +++ b/pymongo/mongo_client_shared.py @@ -17,7 +17,7 @@ from __future__ import annotations from collections.abc import Mapping -from typing import Any, Callable, Generic, Optional, TypeVar, Union, cast +from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, TypeVar, Union, cast from pymongo import _csot from pymongo._telemetry import _generate_op_id_or_none, log_command_retry @@ -35,16 +35,19 @@ _CLIENT_LOGGER, _log_or_warn, ) -from pymongo.read_preferences import _ServerMode -from pymongo.server_selectors import Selection, writable_server_selector -from pymongo.typings import ( - _Address, - _AgnosticBulk, - _AgnosticClientBulk, - _AgnosticClientSession, - _AgnosticMongoClient, - _AgnosticServer, -) +from pymongo.server_selectors import writable_server_selector + +if TYPE_CHECKING: + from pymongo.read_preferences import _ServerMode + from pymongo.server_selectors import Selection + from pymongo.typings import ( + _Address, + _AgnosticBulk, + _AgnosticClientBulk, + _AgnosticClientSession, + _AgnosticMongoClient, + _AgnosticServer, + ) T = TypeVar("T") _ServerT = TypeVar("_ServerT", bound="_AgnosticServer") diff --git a/pymongo/synchronous/mongo_client.py b/pymongo/synchronous/mongo_client.py index 6ae48f0262..63c28d3b0a 100644 --- a/pymongo/synchronous/mongo_client.py +++ b/pymongo/synchronous/mongo_client.py @@ -2856,7 +2856,7 @@ def __enter__(self) -> tuple[Connection, _ServerMode]: # type: ignore[override] class _ClientConnectionRetryable( - _AgnosticClientConnectionRetryableBase[T, "Server", _WriteCall[T] | _ReadCall[T]], Generic[T] + _AgnosticClientConnectionRetryableBase[T, "Server", _WriteCall[T] | _ReadCall[T]] ): """Responsible for executing retryable connections on read or write operations""" From 1f8c12878ffa61e1df723bae49f2019d4fa48357 Mon Sep 17 00:00:00 2001 From: Iris Date: Wed, 4 Nov 2026 11:33:06 -0800 Subject: [PATCH 4/5] copilot feedback --- pymongo/asynchronous/mongo_client.py | 2 ++ pymongo/synchronous/mongo_client.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/pymongo/asynchronous/mongo_client.py b/pymongo/asynchronous/mongo_client.py index 49a08a79a6..fcfe94fd2f 100644 --- a/pymongo/asynchronous/mongo_client.py +++ b/pymongo/asynchronous/mongo_client.py @@ -2871,6 +2871,8 @@ class _ClientConnectionRetryable( ): """Responsible for executing retryable connections on read or write operations""" + __slots__ = () + _client: AsyncMongoClient[Any] _session: Optional[AsyncClientSession] diff --git a/pymongo/synchronous/mongo_client.py b/pymongo/synchronous/mongo_client.py index 63c28d3b0a..52ca029d26 100644 --- a/pymongo/synchronous/mongo_client.py +++ b/pymongo/synchronous/mongo_client.py @@ -2860,6 +2860,8 @@ class _ClientConnectionRetryable( ): """Responsible for executing retryable connections on read or write operations""" + __slots__ = () + _client: MongoClient[Any] _session: Optional[ClientSession] From 5b39231156efe0abe8f0a0f860841f59546db8ef Mon Sep 17 00:00:00 2001 From: Iris Date: Wed, 4 Nov 2026 16:49:58 -0800 Subject: [PATCH 5/5] undo accidental submodule changes --- drivers-evergreen-tools | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers-evergreen-tools b/drivers-evergreen-tools index 354a81692b..e35ecc9d56 160000 --- a/drivers-evergreen-tools +++ b/drivers-evergreen-tools @@ -1 +1 @@ -Subproject commit 354a81692bfd2b654a38277b681d248507d17800 +Subproject commit e35ecc9d563b5dada8185e64b7a571541000bc6d