chore: fix tests and linting (#719)

* cp dines

* cp dines

* cp dines

Author: dines-rl

src/runloop_api_client/resources/blueprints.py

@@ -333,6 +333,7 @@ def create_and_await_build_complete(
         file_mounts: Optional[Dict[str, str]] | Omit = omit,
         launch_parameters: Optional[LaunchParameters] | Omit = omit,
         metadata: Optional[Dict[str, str]] | Omit = omit,
+        network_policy_id: Optional[str] | Omit = omit,
         secrets: Optional[Dict[str, str]] | Omit = omit,
         services: Optional[Iterable[blueprint_create_params.Service]] | Omit = omit,
         system_setup_commands: Optional[SequenceNotStr[str]] | Omit = omit,
@@ -372,6 +373,7 @@ def create_and_await_build_complete(
             file_mounts=file_mounts,
             launch_parameters=launch_parameters,
             metadata=metadata,
+            network_policy_id=network_policy_id,
             secrets=secrets,
             services=services,
             system_setup_commands=system_setup_commands,
@@ -1001,6 +1003,7 @@ async def create_and_await_build_complete(
         file_mounts: Optional[Dict[str, str]] | Omit = omit,
         launch_parameters: Optional[LaunchParameters] | Omit = omit,
         metadata: Optional[Dict[str, str]] | Omit = omit,
+        network_policy_id: Optional[str] | Omit = omit,
         secrets: Optional[Dict[str, str]] | Omit = omit,
         services: Optional[Iterable[blueprint_create_params.Service]] | Omit = omit,
         system_setup_commands: Optional[SequenceNotStr[str]] | Omit = omit,
@@ -1040,6 +1043,7 @@ async def create_and_await_build_complete(
             file_mounts=file_mounts,
             launch_parameters=launch_parameters,
             metadata=metadata,
+            network_policy_id=network_policy_id,
             secrets=secrets,
             services=services,
             system_setup_commands=system_setup_commands,

src/runloop_api_client/sdk/async_benchmark.py

@@ -107,6 +107,7 @@ async def start_run(
             benchmark_id=self._id,
             **params,
         )
+        assert run_view.benchmark_id is not None, "benchmark_id should be set for runs created from a benchmark"
         return AsyncBenchmarkRun(self._client, run_view.id, run_view.benchmark_id)
 
     async def add_scenarios(
@@ -157,8 +158,12 @@ async def list_runs(
         :return: List of async benchmark runs
         :rtype: List[AsyncBenchmarkRun]
         """
-        page = await self._client.benchmarks.runs.list(
+        page = await self._client.benchmark_runs.list(
             benchmark_id=self._id,
             **params,
         )
-        return [AsyncBenchmarkRun(self._client, run.id, run.benchmark_id) for run in page.runs]
+        return [
+            AsyncBenchmarkRun(self._client, run.id, run.benchmark_id)
+            for run in page.runs
+            if run.benchmark_id is not None
+        ]

src/runloop_api_client/sdk/async_benchmark_run.py

@@ -71,7 +71,7 @@ async def get_info(
         :return: Current benchmark run state info
         :rtype: BenchmarkRunView
         """
-        return await self._client.benchmarks.runs.retrieve(
+        return await self._client.benchmark_runs.retrieve(
             self._id,
             **options,
         )
@@ -88,7 +88,7 @@ async def cancel(
         :return: Updated benchmark run state
         :rtype: BenchmarkRunView
         """
-        return await self._client.benchmarks.runs.cancel(
+        return await self._client.benchmark_runs.cancel(
             self._id,
             **options,
         )
@@ -105,7 +105,7 @@ async def complete(
         :return: Completed benchmark run state
         :rtype: BenchmarkRunView
         """
-        return await self._client.benchmarks.runs.complete(
+        return await self._client.benchmark_runs.complete(
             self._id,
             **options,
         )
@@ -120,7 +120,7 @@ async def list_scenario_runs(
         :return: List of async scenario run objects
         :rtype: List[AsyncScenarioRun]
         """
-        page = await self._client.benchmarks.runs.list_scenario_runs(
+        page = await self._client.benchmark_runs.list_scenario_runs(
             self._id,
             **params,
         )

src/runloop_api_client/sdk/benchmark.py

@@ -107,6 +107,7 @@ def start_run(
             benchmark_id=self._id,
             **params,
         )
+        assert run_view.benchmark_id is not None, "benchmark_id should be set for runs created from a benchmark"
         return BenchmarkRun(self._client, run_view.id, run_view.benchmark_id)
 
     def add_scenarios(
@@ -157,8 +158,12 @@ def list_runs(
         :return: List of benchmark runs
         :rtype: List[BenchmarkRun]
         """
-        page = self._client.benchmarks.runs.list(
+        page = self._client.benchmark_runs.list(
             benchmark_id=self._id,
             **params,
         )
-        return [BenchmarkRun(self._client, run.id, run.benchmark_id) for run in page.runs]
+        return [
+            BenchmarkRun(self._client, run.id, run.benchmark_id)
+            for run in page.runs
+            if run.benchmark_id is not None
+        ]

src/runloop_api_client/sdk/benchmark_run.py

@@ -71,7 +71,7 @@ def get_info(
         :return: Current benchmark run state info
         :rtype: BenchmarkRunView
         """
-        return self._client.benchmarks.runs.retrieve(
+        return self._client.benchmark_runs.retrieve(
             self._id,
             **options,
         )
@@ -88,7 +88,7 @@ def cancel(
         :return: Updated benchmark run state
         :rtype: BenchmarkRunView
         """
-        return self._client.benchmarks.runs.cancel(
+        return self._client.benchmark_runs.cancel(
             self._id,
             **options,
         )
@@ -105,7 +105,7 @@ def complete(
         :return: Completed benchmark run state
         :rtype: BenchmarkRunView
         """
-        return self._client.benchmarks.runs.complete(
+        return self._client.benchmark_runs.complete(
             self._id,
             **options,
         )
@@ -120,7 +120,7 @@ def list_scenario_runs(
         :return: List of scenario run objects
         :rtype: List[ScenarioRun]
         """
-        page = self._client.benchmarks.runs.list_scenario_runs(
+        page = self._client.benchmark_runs.list_scenario_runs(
             self._id,
             **params,
         )

tests/sdk/async_devbox/test_core.py

@@ -176,15 +176,15 @@ async def test_resume(self, mock_async_client: AsyncMock, devbox_view: MockDevbo
 
         assert result == devbox_view
         mock_async_client.devboxes.resume.assert_called_once_with(
-            "dev_123",
+            "dbx_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",
+            "dbx_123",
             polling_config=polling_config,
         )
 
@@ -204,7 +204,7 @@ async def test_resume_async(self, mock_async_client: AsyncMock, devbox_view: Moc
 
         assert result == devbox_view
         mock_async_client.devboxes.resume.assert_called_once_with(
-            "dbx_123",
+            "dev_123",
             extra_headers={"X-Custom": "value"},
             extra_query={"param": "value"},
             extra_body={"key": "value"},

tests/sdk/test_async_benchmark.py

@@ -84,7 +84,7 @@ async def test_list_runs_single(
     ) -> None:
         """Test list_runs method with single result."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_async_client.benchmarks.runs.list = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list = AsyncMock(return_value=page)
 
         benchmark = AsyncBenchmark(mock_async_client, "bmd_123")
         result = await benchmark.list_runs()
@@ -93,14 +93,14 @@ async def test_list_runs_single(
         assert isinstance(result[0], AsyncBenchmarkRun)
         assert result[0].id == benchmark_run_view.id
         assert result[0].benchmark_id == benchmark_run_view.benchmark_id
-        mock_async_client.benchmarks.runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
+        mock_async_client.benchmark_runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
 
     async def test_list_runs_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list_runs method with multiple results."""
         run_view1 = MockBenchmarkRunView(id="bmr_001")
         run_view2 = MockBenchmarkRunView(id="bmr_002")
         page = SimpleNamespace(runs=[run_view1, run_view2])
-        mock_async_client.benchmarks.runs.list = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list = AsyncMock(return_value=page)
 
         benchmark = AsyncBenchmark(mock_async_client, "bmd_123")
         result = await benchmark.list_runs()
@@ -112,19 +112,19 @@ async def test_list_runs_multiple(self, mock_async_client: AsyncMock) -> None:
         assert result[0].benchmark_id == run_view1.benchmark_id
         assert result[1].id == run_view2.id
         assert result[1].benchmark_id == run_view2.benchmark_id
-        mock_async_client.benchmarks.runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
+        mock_async_client.benchmark_runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
 
     async def test_list_runs_with_params(
         self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView
     ) -> None:
         """Test list_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_async_client.benchmarks.runs.list = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list = AsyncMock(return_value=page)
 
         benchmark = AsyncBenchmark(mock_async_client, "bmd_123")
         result = await benchmark.list_runs(limit=10, name="test-run")
 
         assert len(result) == 1
-        mock_async_client.benchmarks.runs.list.assert_awaited_once_with(
+        mock_async_client.benchmark_runs.list.assert_awaited_once_with(
             benchmark_id="bmd_123", limit=10, name="test-run"
         )

tests/sdk/test_async_benchmark_run.py

@@ -26,55 +26,55 @@ def test_repr(self, mock_async_client: AsyncMock) -> None:
 
     async def test_get_info(self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test get_info method."""
-        mock_async_client.benchmarks.runs.retrieve = AsyncMock(return_value=benchmark_run_view)
+        mock_async_client.benchmark_runs.retrieve = AsyncMock(return_value=benchmark_run_view)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.get_info()
 
         assert result == benchmark_run_view
-        mock_async_client.benchmarks.runs.retrieve.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.retrieve.assert_awaited_once_with("bmr_123")
 
     async def test_cancel(self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test cancel method."""
         benchmark_run_view.state = "canceled"
-        mock_async_client.benchmarks.runs.cancel = AsyncMock(return_value=benchmark_run_view)
+        mock_async_client.benchmark_runs.cancel = AsyncMock(return_value=benchmark_run_view)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.cancel()
 
         assert result == benchmark_run_view
         assert result.state == "canceled"
-        mock_async_client.benchmarks.runs.cancel.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.cancel.assert_awaited_once_with("bmr_123")
 
     async def test_complete(self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test complete method."""
         benchmark_run_view.state = "completed"
-        mock_async_client.benchmarks.runs.complete = AsyncMock(return_value=benchmark_run_view)
+        mock_async_client.benchmark_runs.complete = AsyncMock(return_value=benchmark_run_view)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.complete()
 
         assert result == benchmark_run_view
         assert result.state == "completed"
-        mock_async_client.benchmarks.runs.complete.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.complete.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_empty(self, mock_async_client: AsyncMock) -> None:
         """Test list_scenario_runs method with empty results."""
         page = SimpleNamespace(runs=[])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs()
 
         assert len(result) == 0
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_single(
         self, mock_async_client: AsyncMock, scenario_run_view: MockScenarioRunView
     ) -> None:
         """Test list_scenario_runs method with single result."""
         page = SimpleNamespace(runs=[scenario_run_view])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs()
@@ -83,14 +83,14 @@ async def test_list_scenario_runs_single(
         assert isinstance(result[0], AsyncScenarioRun)
         assert result[0].id == scenario_run_view.id
         assert result[0].devbox_id == scenario_run_view.devbox_id
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list_scenario_runs method with multiple results."""
         scenario_run_view1 = MockScenarioRunView(id="scr_001", devbox_id="dev_001")
         scenario_run_view2 = MockScenarioRunView(id="scr_002", devbox_id="dev_002")
         page = SimpleNamespace(runs=[scenario_run_view1, scenario_run_view2])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs()
@@ -100,21 +100,21 @@ async def test_list_scenario_runs_multiple(self, mock_async_client: AsyncMock) -
         assert isinstance(result[1], AsyncScenarioRun)
         assert result[0].id == "scr_001"
         assert result[1].id == "scr_002"
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_with_params(
         self, mock_async_client: AsyncMock, scenario_run_view: MockScenarioRunView
     ) -> None:
         """Test list_scenario_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[scenario_run_view])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs(limit=10, state="completed")
 
         assert len(result) == 1
         assert isinstance(result[0], AsyncScenarioRun)
         assert result[0].id == scenario_run_view.id
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with(
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with(
             "bmr_123", limit=10, state="completed"
         )

tests/sdk/test_benchmark.py

@@ -80,7 +80,7 @@ def test_remove_scenarios(self, mock_client: Mock, benchmark_view: MockBenchmark
     def test_list_runs_single(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test list_runs method with single result."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_client.benchmarks.runs.list.return_value = page
+        mock_client.benchmark_runs.list.return_value = page
 
         benchmark = Benchmark(mock_client, "bmd_123")
         result = benchmark.list_runs()
@@ -89,14 +89,14 @@ def test_list_runs_single(self, mock_client: Mock, benchmark_run_view: MockBench
         assert isinstance(result[0], BenchmarkRun)
         assert result[0].id == benchmark_run_view.id
         assert result[0].benchmark_id == benchmark_run_view.benchmark_id
-        mock_client.benchmarks.runs.list.assert_called_once_with(benchmark_id="bmd_123")
+        mock_client.benchmark_runs.list.assert_called_once_with(benchmark_id="bmd_123")
 
     def test_list_runs_multiple(self, mock_client: Mock) -> None:
         """Test list_runs method with multiple results."""
         run_view1 = MockBenchmarkRunView(id="bmr_001")
         run_view2 = MockBenchmarkRunView(id="bmr_002")
         page = SimpleNamespace(runs=[run_view1, run_view2])
-        mock_client.benchmarks.runs.list.return_value = page
+        mock_client.benchmark_runs.list.return_value = page
 
         benchmark = Benchmark(mock_client, "bmd_123")
         result = benchmark.list_runs()
@@ -108,15 +108,15 @@ def test_list_runs_multiple(self, mock_client: Mock) -> None:
         assert result[0].benchmark_id == run_view1.benchmark_id
         assert result[1].id == run_view2.id
         assert result[1].benchmark_id == run_view2.benchmark_id
-        mock_client.benchmarks.runs.list.assert_called_once_with(benchmark_id="bmd_123")
+        mock_client.benchmark_runs.list.assert_called_once_with(benchmark_id="bmd_123")
 
     def test_list_runs_with_params(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test list_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_client.benchmarks.runs.list.return_value = page
+        mock_client.benchmark_runs.list.return_value = page
 
         benchmark = Benchmark(mock_client, "bmd_123")
         result = benchmark.list_runs(limit=10, name="test-run")
 
         assert len(result) == 1
-        mock_client.benchmarks.runs.list.assert_called_once_with(benchmark_id="bmd_123", limit=10, name="test-run")
+        mock_client.benchmark_runs.list.assert_called_once_with(benchmark_id="bmd_123", limit=10, name="test-run")