Revert "cp dines (#697)"

This reverts commit 34f2dd0.

Author: dines-rl

src/runloop_api_client/sdk/async_devbox.py

@@ -172,36 +172,18 @@ async def suspend(
 
     async def resume(
         self,
-        *,
-        polling_config: PollingConfig | None = None,
         **options: Unpack[LongRequestOptions],
     ) -> DevboxView:
-        """Resume a suspended devbox, restoring it to running state.
+        """Resume a suspended devbox.
 
-        Waits for the devbox to reach running state before returning.
+        Returns immediately after issuing the resume request. Call
+        :meth:`await_running` if you need to wait for the devbox to reach the
+        ``running`` state (contrast with the synchronous SDK, which blocks).
 
-        :param polling_config: Optional polling behavior overrides, defaults to None
-        :type polling_config: PollingConfig | None, optional
         :param options: Optional long-running request configuration
         :return: Resumed devbox state info
         :rtype: DevboxView
         """
-        await self.resume_async(**options)
-        return await self.await_running(polling_config=polling_config)
-
-    async def resume_async(
-        self,
-        **options: Unpack[LongRequestOptions],
-    ) -> DevboxView:
-        """Resume a suspended devbox without waiting for it to reach running state.
-
-        Initiates the resume operation and returns immediately. Use :meth:`await_running`
-        to wait for the devbox to reach running state if needed.
-
-        :param options: Optional long-running request configuration
-        :return: Devbox state info immediately after resume request
-        :rtype: DevboxView
-        """
         return await self._client.devboxes.resume(
             self._id,
             **options,

src/runloop_api_client/sdk/devbox.py

@@ -185,26 +185,11 @@ def resume(
         :return: Resumed devbox state info
         :rtype: :class:`~runloop_api_client.types.devbox_view.DevboxView`
         """
-        self.resume_async(**filter_params(options, LongRequestOptions))
-        return self._client.devboxes.await_running(self._id, polling_config=options.get("polling_config"))
-
-    def resume_async(
-        self,
-        **options: Unpack[LongRequestOptions],
-    ) -> DevboxView:
-        """Resume a suspended devbox without waiting for it to reach running state.
-
-        Initiates the resume operation and returns immediately. Use :meth:`await_running`
-        to wait for the devbox to reach running state if needed.
-
-        :param options: Optional long-running request configuration
-        :return: Devbox state info immediately after resume request
-        :rtype: :class:`~runloop_api_client.types.devbox_view.DevboxView`
-        """
-        return self._client.devboxes.resume(
+        self._client.devboxes.resume(
             self._id,
-            **options,
+            **filter_params(options, LongRequestOptions),
         )
+        return self._client.devboxes.await_running(self._id, polling_config=options.get("polling_config"))
 
     def keep_alive(
         self,

tests/sdk/async_devbox/test_core.py

@@ -161,40 +161,9 @@ async def test_suspend(self, mock_async_client: AsyncMock, devbox_view: MockDevb
     async def test_resume(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
         """Test resume method."""
         mock_async_client.devboxes.resume = AsyncMock(return_value=devbox_view)
-        mock_async_client.devboxes.await_running = AsyncMock(return_value=devbox_view)
-        polling_config = PollingConfig(timeout_seconds=60.0)
 
         devbox = AsyncDevbox(mock_async_client, "dbx_123")
         result = await devbox.resume(
-            polling_config=polling_config,
-            extra_headers={"X-Custom": "value"},
-            extra_query={"param": "value"},
-            extra_body={"key": "value"},
-            timeout=30.0,
-            idempotency_key="key-123",
-        )
-
-        assert result == devbox_view
-        mock_async_client.devboxes.resume.assert_called_once_with(
-            "dev_123",
-            extra_headers={"X-Custom": "value"},
-            extra_query={"param": "value"},
-            extra_body={"key": "value"},
-            timeout=30.0,
-            idempotency_key="key-123",
-        )
-        mock_async_client.devboxes.await_running.assert_called_once_with(
-            "dev_123",
-            polling_config=polling_config,
-        )
-
-    @pytest.mark.asyncio
-    async def test_resume_async(self, mock_async_client: AsyncMock, devbox_view: MockDevboxView) -> None:
-        """Test resume_async method."""
-        mock_async_client.devboxes.resume = AsyncMock(return_value=devbox_view)
-
-        devbox = AsyncDevbox(mock_async_client, "dev_123")
-        result = await devbox.resume_async(
             extra_headers={"X-Custom": "value"},
             extra_query={"param": "value"},
             extra_body={"key": "value"},

tests/sdk/devbox/test_core.py

@@ -190,32 +190,6 @@ def test_resume(self, mock_client: Mock, devbox_view: MockDevboxView) -> None:
             polling_config=polling_config,
         )
 
-    def test_resume_async(self, mock_client: Mock, devbox_view: MockDevboxView) -> None:
-        """Test resume_async method."""
-        mock_client.devboxes.resume.return_value = devbox_view
-        mock_client.devboxes.await_running = Mock()
-
-        devbox = Devbox(mock_client, "dev_123")
-        result = devbox.resume_async(
-            extra_headers={"X-Custom": "value"},
-            extra_query={"param": "value"},
-            extra_body={"key": "value"},
-            timeout=30.0,
-            idempotency_key="key-123",
-        )
-
-        assert result == devbox_view
-        mock_client.devboxes.resume.assert_called_once_with(
-            "dev_123",
-            extra_headers={"X-Custom": "value"},
-            extra_query={"param": "value"},
-            extra_body={"key": "value"},
-            timeout=30.0,
-            idempotency_key="key-123",
-        )
-        # Should not call await_running
-        mock_client.devboxes.await_running.assert_not_called()
-
     def test_keep_alive(self, mock_client: Mock) -> None:
         """Test keep_alive method."""
         mock_client.devboxes.keep_alive.return_value = object()

tests/smoketests/sdk/test_async_devbox.py

@@ -346,10 +346,12 @@ async def test_suspend_and_resume(self, async_sdk_client: AsyncRunloopSDK) -> No
             info = await devbox.get_info()
             assert info.status == "suspended"
 
-            # Resume the devbox - resume() automatically waits for running state
-            resumed_info = await devbox.resume(
-                polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0)
-            )
+            # Resume the devbox
+            resumed_info = await devbox.resume()
+            if resumed_info.status != "running":
+                resumed_info = await devbox.await_running(
+                    polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0)
+                )
             assert resumed_info.status == "running"
 
             # Verify running state
@@ -358,43 +360,6 @@ async def test_suspend_and_resume(self, async_sdk_client: AsyncRunloopSDK) -> No
         finally:
             await devbox.shutdown()
 
-    @pytest.mark.timeout(TWO_MINUTE_TIMEOUT)
-    async def test_resume_async(self, async_sdk_client: AsyncRunloopSDK) -> None:
-        """Test resuming a devbox asynchronously without waiting."""
-        devbox = await async_sdk_client.devbox.create(
-            name=unique_name("sdk-async-devbox-resume-async"),
-            launch_parameters={"resource_size_request": "SMALL", "keep_alive_time_seconds": 60 * 5},
-        )
-
-        try:
-            # Suspend the devbox
-            suspended_info = await devbox.suspend()
-            if suspended_info.status != "suspended":
-                suspended_info = await devbox.await_suspended(
-                    polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0)
-                )
-            assert suspended_info.status == "suspended"
-
-            # Verify suspended state
-            info = await devbox.get_info()
-            assert info.status == "suspended"
-
-            # Resume the devbox asynchronously - doesn't wait automatically
-            resume_response = await devbox.resume_async()
-            assert resume_response is not None
-
-            # Status might still be suspended or transitioning
-            info_after_resume = await devbox.get_info()
-            assert info_after_resume.status in ["suspended", "running", "starting"]
-
-            # Now wait for running state explicitly
-            running_info = await devbox.await_running(
-                polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0)
-            )
-            assert running_info.status == "running"
-        finally:
-            await devbox.shutdown()
-
     @pytest.mark.timeout(TWO_MINUTE_TIMEOUT)
     async def test_await_running(self, async_sdk_client: AsyncRunloopSDK) -> None:
         """Test await_running method."""

tests/smoketests/sdk/test_devbox.py

@@ -345,7 +345,7 @@ def test_suspend_and_resume(self, sdk_client: RunloopSDK) -> None:
             info = devbox.get_info()
             assert info.status == "suspended"
 
-            # Resume the devbox - resume() automatically waits for running state
+            # Resume the devbox
             resumed_info = devbox.resume(
                 polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0),
             )
@@ -357,41 +357,6 @@ def test_suspend_and_resume(self, sdk_client: RunloopSDK) -> None:
         finally:
             devbox.shutdown()
 
-    @pytest.mark.timeout(TWO_MINUTE_TIMEOUT)
-    def test_resume_async(self, sdk_client: RunloopSDK) -> None:
-        """Test resuming a devbox asynchronously without waiting."""
-        devbox = sdk_client.devbox.create(
-            name=unique_name("sdk-devbox-resume-async"),
-            launch_parameters={"resource_size_request": "SMALL", "keep_alive_time_seconds": 60 * 5},
-        )
-
-        try:
-            # Suspend the devbox
-            suspended_info = devbox.suspend(
-                polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0),
-            )
-            assert suspended_info.status == "suspended"
-
-            # Verify suspended state
-            info = devbox.get_info()
-            assert info.status == "suspended"
-
-            # Resume the devbox asynchronously - doesn't wait automatically
-            resume_response = devbox.resume_async()
-            assert resume_response is not None
-
-            # Status might still be suspended or transitioning
-            info_after_resume = devbox.get_info()
-            assert info_after_resume.status in ["suspended", "running", "starting"]
-
-            # Now wait for running state explicitly
-            running_info = devbox.await_running(
-                polling_config=PollingConfig(timeout_seconds=120.0, interval_seconds=5.0)
-            )
-            assert running_info.status == "running"
-        finally:
-            devbox.shutdown()
-
     @pytest.mark.timeout(TWO_MINUTE_TIMEOUT)
     def test_await_running(self, sdk_client: RunloopSDK) -> None:
         """Test await_running method."""