self.assertEqual(init_process_execute.process.returncode, 0)
 
-        with open(EXPECTED_JENKINS_FILE_PATH, "r") as expected, open(
-            os.path.join(".aws-sam", "pipeline", "generated-files", "Jenkinsfile"), "r"
-        ) as output:
+        with (
+            open(EXPECTED_JENKINS_FILE_PATH, "r") as expected,
+            open(os.path.join(".aws-sam", "pipeline", "generated-files", "Jenkinsfile"), "r") as output,
+        ):
             self.assertEqual(expected.read(), output.read())
 
         # also check the Jenkinsfile is not overridden

         }
 
         # NOTE: Because we don't load the full Click BaseCommand here, this is mounted as top-level command
-        with samconfig_parameters(
-            ["start-lambda"], self.scratch_dir, **config_values
-        ) as config_path, tempfile.NamedTemporaryFile() as key_file, tempfile.NamedTemporaryFile() as cert_file:
+        with (
+            samconfig_parameters(["start-lambda"], self.scratch_dir, **config_values) as config_path,
+            tempfile.NamedTemporaryFile() as key_file,
+            tempfile.NamedTemporaryFile() as cert_file,
+        ):
             from samcli.commands.local.start_lambda.cli import cli
 
             LOG.debug(Path(config_path).read_text())

         }
 
         # NOTE: Because we don't load the full Click BaseCommand here, this is mounted as top-level command
-        with samconfig_parameters(
-            ["start-lambda"], self.scratch_dir, **config_values
-        ) as config_path, tempfile.NamedTemporaryFile() as key_file, tempfile.NamedTemporaryFile() as cert_file:
+        with (
+            samconfig_parameters(["start-lambda"], self.scratch_dir, **config_values) as config_path,
+            tempfile.NamedTemporaryFile() as key_file,
+            tempfile.NamedTemporaryFile() as cert_file,
+        ):
             from samcli.commands.local.start_lambda.cli import cli
 
             LOG.debug(Path(config_path).read_text())

     def test_will_call_incremental_build_strategy(self, mocked_read, mocked_write, runtime):
         build_definition = FunctionBuildDefinition(runtime, "codeuri", None, "package_type", X86_64, {}, "handler")
         self.build_graph.put_function_build_definition(build_definition, Mock(full_path="function_full_path"))
-        with patch.object(
-            self.build_strategy, "_incremental_build_strategy"
-        ) as patched_incremental_build_strategy, patch.object(
-            self.build_strategy, "_cached_build_strategy"
-        ) as patched_cached_build_strategy:
+        with (
+            patch.object(self.build_strategy, "_incremental_build_strategy") as patched_incremental_build_strategy,
+            patch.object(self.build_strategy, "_cached_build_strategy") as patched_cached_build_strategy,
+        ):
             self.build_strategy.build()
 
             patched_incremental_build_strategy.build_single_function_definition.assert_called_with(build_definition)

     def test_will_call_cached_build_strategy(self, mocked_read, mocked_write, runtime):
         build_definition = FunctionBuildDefinition(runtime, "codeuri", None, "package_type", X86_64, {}, "handler")
         self.build_graph.put_function_build_definition(build_definition, Mock(full_path="function_full_path"))
-        with patch.object(
-            self.build_strategy, "_incremental_build_strategy"
-        ) as patched_incremental_build_strategy, patch.object(
-            self.build_strategy, "_cached_build_strategy"
-        ) as patched_cached_build_strategy:
+        with (
+            patch.object(self.build_strategy, "_incremental_build_strategy") as patched_incremental_build_strategy,
+            patch.object(self.build_strategy, "_cached_build_strategy") as patched_cached_build_strategy,
+        ):
             self.build_strategy.build()
 
             patched_cached_build_strategy.build_single_function_definition.assert_called_with(build_definition)

 
         build_definition = FunctionBuildDefinition(runtime, "codeuri", None, "package_type", X86_64, {}, "handler")
         self.build_graph.put_function_build_definition(build_definition, Mock(full_path="function_full_path"))
-        with patch.object(
-            build_strategy, "_incremental_build_strategy"
-        ) as patched_incremental_build_strategy, patch.object(
-            build_strategy, "_cached_build_strategy"
-        ) as patched_cached_build_strategy:
+        with (
+            patch.object(build_strategy, "_incremental_build_strategy") as patched_incremental_build_strategy,
+            patch.object(build_strategy, "_cached_build_strategy") as patched_cached_build_strategy,
+        ):
             build_strategy.build()
 
             if not use_container:

         given_output_format = "text"
         test_execution_info = RemoteInvokeExecutionInfo(given_payload, None, given_parameters, given_output_format)
 
-        with patch.object(self.boto_action_executor, "_execute_action") as patched_execute_action, patch.object(
-            self.boto_action_executor, "_execute_action_file"
-        ) as patched_execute_action_file:
+        with (
+            patch.object(self.boto_action_executor, "_execute_action") as patched_execute_action,
+            patch.object(self.boto_action_executor, "_execute_action_file") as patched_execute_action_file,
+        ):
             given_result = Mock()
             patched_execute_action.return_value = given_result
 

         given_output_format = "json"
         test_execution_info = RemoteInvokeExecutionInfo(None, given_payload_file, given_parameters, given_output_format)
 
-        with patch.object(self.boto_action_executor, "_execute_action") as patched_execute_action, patch.object(
-            self.boto_action_executor, "_execute_action_file"
-        ) as patched_execute_action_file:
+        with (
+            patch.object(self.boto_action_executor, "_execute_action") as patched_execute_action,
+            patch.object(self.boto_action_executor, "_execute_action_file") as patched_execute_action_file,
+        ):
             given_result = Mock()
             patched_execute_action_file.return_value = given_result
 

     mock_collection.find = mock_find
     mock_collection.count_documents = mock_count_documents
 
-    with patch(
-        "motor.motor_asyncio.AsyncIOMotorClient", return_value=MagicMock()
-    ), patch(
-        "langchain_community.document_loaders.mongodb.MongodbLoader.aload",
-        new=mock_async_load,
+    with (
+        patch("motor.motor_asyncio.AsyncIOMotorClient", return_value=MagicMock()),
+        patch(
+            "langchain_community.document_loaders.mongodb.MongodbLoader.aload",
+            new=mock_async_load,
+        ),
     ):
         loader = MongodbLoader(
             "mongodb://localhost:27017",

 def test_huggingface_tts_run_with_requests_mock() -> None:
     os.environ["HUGGINGFACE_API_KEY"] = "foo"
 
-    with tempfile.TemporaryDirectory() as tmp_dir, patch(
-        "uuid.uuid4"
-    ) as mock_uuid, patch("requests.post") as mock_inference, patch(
-        "builtins.open", mock_open()
-    ) as mock_file:
+    with (
+        tempfile.TemporaryDirectory() as tmp_dir,
+        patch("uuid.uuid4") as mock_uuid,
+        patch("requests.post") as mock_inference,
+        patch("builtins.open", mock_open()) as mock_file,
+    ):
         input_query = "Dummy input"
 
         mock_uuid_value = uuid.UUID("00000000-0000-0000-0000-000000000000")

     ]
     ids_provided = [i.metadata.get("id") for i in documents]
 
-    with patch.object(
-        SearchClient, "upload_documents", mock_upload_documents
-    ), patch.object(SearchIndexClient, "get_index", mock_default_index):
+    with (
+        patch.object(SearchClient, "upload_documents", mock_upload_documents),
+        patch.object(SearchIndexClient, "get_index", mock_default_index),
+    ):
         vector_store = create_vector_store()
         ids_used_at_upload = vector_store.add_documents(documents, ids=ids_provided)
         assert len(ids_provided) == len(ids_used_at_upload)

         proj.id = "123"
         return proj
 
-    with mock.patch.object(
-        Client, "read_dataset", new=mock_read_dataset
-    ), mock.patch.object(Client, "list_examples", new=mock_list_examples), mock.patch(
-        "langchain.smith.evaluation.runner_utils._arun_llm_or_chain",
-        new=mock_arun_chain,
-    ), mock.patch.object(Client, "create_project", new=mock_create_project):
+    with (
+        mock.patch.object(Client, "read_dataset", new=mock_read_dataset),
+        mock.patch.object(Client, "list_examples", new=mock_list_examples),
+        mock.patch(
+            "langchain.smith.evaluation.runner_utils._arun_llm_or_chain",
+            new=mock_arun_chain,
+        ),
+        mock.patch.object(Client, "create_project", new=mock_create_project),
+    ):
         client = Client(api_url="http://localhost:1984", api_key="123")
         chain = mock.MagicMock()
         chain.input_keys = ["foothing"]

 
 def test_bind_tools(chat_hugging_face: Any) -> None:
     tools = [MagicMock(spec=BaseTool)]
-    with patch(
-        "langchain_huggingface.chat_models.huggingface.convert_to_openai_tool",
-        side_effect=lambda x: x,
-    ), patch("langchain_core.runnables.base.Runnable.bind") as mock_super_bind:
+    with (
+        patch(
+            "langchain_huggingface.chat_models.huggingface.convert_to_openai_tool",
+            side_effect=lambda x: x,
+        ),
+        patch("langchain_core.runnables.base.Runnable.bind") as mock_super_bind,
+    ):
         chat_hugging_face.bind_tools(tools, tool_choice="auto")
         mock_super_bind.assert_called_once()
         _, kwargs = mock_super_bind.call_args

         run_status = DbtCloudJobRunStatus(run_data.get("status"))
         if run_status == DbtCloudJobRunStatus.SUCCESS:
             try:
-                async with self._dbt_cloud_credentials.get_administrative_client() as client:  # noqa
+                async with (
+                    self._dbt_cloud_credentials.get_administrative_client() as client
+                ):  # noqa
                     response = await client.list_run_artifacts(
                         run_id=self.run_id, step=step
                     )

             webserver = await build_server(runner)
             client = TestClient(webserver)
 
-            with mock.patch(
-                "prefect.runner.server.get_client", new=mock_get_client
-            ), mock.patch.object(runner, "execute_in_background"):
+            with (
+                mock.patch("prefect.runner.server.get_client", new=mock_get_client),
+                mock.patch.object(runner, "execute_in_background"),
+            ):
                 with client:
                     response = client.post(f"/deployment/{deployment_id}/run")
                 assert response.status_code == 201, response.json()

             )
             await queue.put(task_run)
 
-        with patch("asyncio.sleep", return_value=None), pytest.raises(
-            asyncio.TimeoutError
+        with (
+            patch("asyncio.sleep", return_value=None),
+            pytest.raises(asyncio.TimeoutError),
         ):
             extra_task_run = ServerTaskRun(
                 id=uuid4(),

         )
         await queue.retry(task_run)
 
-        with patch("asyncio.sleep", return_value=None), pytest.raises(
-            asyncio.TimeoutError
+        with (
+            patch("asyncio.sleep", return_value=None),
+            pytest.raises(asyncio.TimeoutError),
         ):
             extra_task_run = ServerTaskRun(
                 id=uuid4(),

 async def test_handle_sigterm(mock_create_subscription):
     task_worker = TaskWorker(...)
 
-    with patch("sys.exit") as mock_exit, patch.object(
-        task_worker, "stop", new_callable=AsyncMock
-    ) as mock_stop:
+    with (
+        patch("sys.exit") as mock_exit,
+        patch.object(task_worker, "stop", new_callable=AsyncMock) as mock_stop,
+    ):
         await task_worker.start()
 
         mock_create_subscription.assert_called_once()

 
 
 async def test_task_worker_client_id_is_set():
-    with patch("socket.gethostname", return_value="foo"), patch(
-        "os.getpid", return_value=42
+    with (
+        patch("socket.gethostname", return_value="foo"),
+        patch("os.getpid", return_value=42),
     ):
         task_worker = TaskWorker(...)
         task_worker._client = MagicMock(api_url="http://localhost:4200")

     ):
         async with WorkerTestImpl(work_pool_name=work_pool.name) as worker:
             await worker.start(run_once=True)
-            with mock.patch(
-                "prefect.workers.base.load_prefect_collections"
-            ) as mock_load_prefect_collections, mock.patch(
-                "prefect.client.orchestration.PrefectHttpxAsyncClient.post"
-            ) as mock_send_worker_heartbeat_post, mock.patch(
-                "prefect.workers.base.distributions"
-            ) as mock_distributions:
+            with (
+                mock.patch(
+                    "prefect.workers.base.load_prefect_collections"
+                ) as mock_load_prefect_collections,
+                mock.patch(
+                    "prefect.client.orchestration.PrefectHttpxAsyncClient.post"
+                ) as mock_send_worker_heartbeat_post,
+                mock.patch("prefect.workers.base.distributions") as mock_distributions,
+            ):
                 mock_load_prefect_collections.return_value = {
                     "prefect_aws": "1.0.0",
                 }

 
         async with CustomWorker(work_pool_name=work_pool.name) as worker:
             await worker.start(run_once=True)
-            with mock.patch(
-                "prefect.workers.base.load_prefect_collections"
-            ) as mock_load_prefect_collections, mock.patch(
-                "prefect.client.orchestration.PrefectHttpxAsyncClient.post"
-            ) as mock_send_worker_heartbeat_post, mock.patch(
-                "prefect.workers.base.distributions"
-            ) as mock_distributions:
+            with (
+                mock.patch(
+                    "prefect.workers.base.load_prefect_collections"
+                ) as mock_load_prefect_collections,
+                mock.patch(
+                    "prefect.client.orchestration.PrefectHttpxAsyncClient.post"
+                ) as mock_send_worker_heartbeat_post,
+                mock.patch("prefect.workers.base.distributions") as mock_distributions,
+            ):
                 mock_load_prefect_collections.return_value = {
                     "prefect_aws": "1.0.0",
                 }

     read_bytes_mock = Mock(return_value=creation_statement.encode())
 
     # Backup table
-    with patch("os.path.getmtime", side_effect=mtime), patch(
-        "ch_backup.logic.table.Path", read_bytes=read_bytes_mock
+    with (
+        patch("os.path.getmtime", side_effect=mtime),
+        patch("ch_backup.logic.table.Path", read_bytes=read_bytes_mock),
     ):
         table_backup.backup(
             context,

         forward_file_path, backward_file_name, read_conf, encrypt_conf, write_conf
     )
 
-    with open(original_file_path, "rb") as orig_fobj, open(
-        backward_file_name, "rb"
-    ) as res_fobj:
+    with (
+        open(original_file_path, "rb") as orig_fobj,
+        open(backward_file_name, "rb") as res_fobj,
+    ):
         orig_contents = orig_fobj.read()
         res_contents = res_fobj.read()
 

 
         self.assertEqual(init_process_execute.process.returncode, 0)
 
-        with open(EXPECTED_JENKINS_FILE_PATH, "r") as expected, open(
-            os.path.join(".aws-sam", "pipeline", "generated-files", "Jenkinsfile"), "r"
-        ) as output:
+        with (
+            open(EXPECTED_JENKINS_FILE_PATH, "r") as expected,
+            open(os.path.join(".aws-sam", "pipeline", "generated-files", "Jenkinsfile"), "r") as output,
+        ):
             self.assertEqual(expected.read(), output.read())
 
         # also check the Jenkinsfile is not overridden

         }
 
         # NOTE: Because we don't load the full Click BaseCommand here, this is mounted as top-level command
-        with samconfig_parameters(
-            ["start-lambda"], self.scratch_dir, **config_values
-        ) as config_path, tempfile.NamedTemporaryFile() as key_file, tempfile.NamedTemporaryFile() as cert_file:
+        with (
+            samconfig_parameters(["start-lambda"], self.scratch_dir, **config_values) as config_path,
+            tempfile.NamedTemporaryFile() as key_file,
+            tempfile.NamedTemporaryFile() as cert_file,
+        ):
             from samcli.commands.local.start_lambda.cli import cli
 
             LOG.debug(Path(config_path).read_text())

         }
 
         # NOTE: Because we don't load the full Click BaseCommand here, this is mounted as top-level command
-        with samconfig_parameters(
-            ["start-lambda"], self.scratch_dir, **config_values
-        ) as config_path, tempfile.NamedTemporaryFile() as key_file, tempfile.NamedTemporaryFile() as cert_file:
+        with (
+            samconfig_parameters(["start-lambda"], self.scratch_dir, **config_values) as config_path,
+            tempfile.NamedTemporaryFile() as key_file,
+            tempfile.NamedTemporaryFile() as cert_file,
+        ):
             from samcli.commands.local.start_lambda.cli import cli
 
             LOG.debug(Path(config_path).read_text())

     def test_will_call_incremental_build_strategy(self, mocked_read, mocked_write, runtime):
         build_definition = FunctionBuildDefinition(runtime, "codeuri", None, "package_type", X86_64, {}, "handler")
         self.build_graph.put_function_build_definition(build_definition, Mock(full_path="function_full_path"))
-        with patch.object(
-            self.build_strategy, "_incremental_build_strategy"
-        ) as patched_incremental_build_strategy, patch.object(
-            self.build_strategy, "_cached_build_strategy"
-        ) as patched_cached_build_strategy:
+        with (
+            patch.object(self.build_strategy, "_incremental_build_strategy") as patched_incremental_build_strategy,
+            patch.object(self.build_strategy, "_cached_build_strategy") as patched_cached_build_strategy,
+        ):
             self.build_strategy.build()
 
             patched_incremental_build_strategy.build_single_function_definition.assert_called_with(build_definition)

     def test_will_call_cached_build_strategy(self, mocked_read, mocked_write, runtime):
         build_definition = FunctionBuildDefinition(runtime, "codeuri", None, "package_type", X86_64, {}, "handler")
         self.build_graph.put_function_build_definition(build_definition, Mock(full_path="function_full_path"))
-        with patch.object(
-            self.build_strategy, "_incremental_build_strategy"
-        ) as patched_incremental_build_strategy, patch.object(
-            self.build_strategy, "_cached_build_strategy"
-        ) as patched_cached_build_strategy:
+        with (
+            patch.object(self.build_strategy, "_incremental_build_strategy") as patched_incremental_build_strategy,
+            patch.object(self.build_strategy, "_cached_build_strategy") as patched_cached_build_strategy,
+        ):
             self.build_strategy.build()
 
             patched_cached_build_strategy.build_single_function_definition.assert_called_with(build_definition)

 
         build_definition = FunctionBuildDefinition(runtime, "codeuri", None, "package_type", X86_64, {}, "handler")
         self.build_graph.put_function_build_definition(build_definition, Mock(full_path="function_full_path"))
-        with patch.object(
-            build_strategy, "_incremental_build_strategy"
-        ) as patched_incremental_build_strategy, patch.object(
-            build_strategy, "_cached_build_strategy"
-        ) as patched_cached_build_strategy:
+        with (
+            patch.object(build_strategy, "_incremental_build_strategy") as patched_incremental_build_strategy,
+            patch.object(build_strategy, "_cached_build_strategy") as patched_cached_build_strategy,
+        ):
             build_strategy.build()
 
             if not use_container:

         given_output_format = "text"
         test_execution_info = RemoteInvokeExecutionInfo(given_payload, None, given_parameters, given_output_format)
 
-        with patch.object(self.boto_action_executor, "_execute_action") as patched_execute_action, patch.object(
-            self.boto_action_executor, "_execute_action_file"
-        ) as patched_execute_action_file:
+        with (
+            patch.object(self.boto_action_executor, "_execute_action") as patched_execute_action,
+            patch.object(self.boto_action_executor, "_execute_action_file") as patched_execute_action_file,
+        ):
             given_result = Mock()
             patched_execute_action.return_value = given_result
 

         given_output_format = "json"
     ...*[Comment body truncated]*