fix(sdk): fixed pagination for scorer, scenario and network policy list methods

src/runloop_api_client/sdk/async_.py

@@ -557,7 +557,7 @@ async def list(self, **params: Unpack[SDKScorerListParams]) -> list[AsyncScorer]
         :rtype: list[AsyncScorer]
         """
         page = await self._client.scenarios.scorers.list(**params)
-        return [AsyncScorer(self._client, item.id) async for item in page]
+        return [AsyncScorer(self._client, item.id) for item in page.scorers]
 
 
 class AsyncAgentOps:
@@ -818,7 +818,7 @@ async def list(self, **params: Unpack[SDKScenarioListParams]) -> list[AsyncScena
         :rtype: list[AsyncScenario]
         """
         page = await self._client.scenarios.list(**params)
-        return [AsyncScenario(self._client, item.id) async for item in page]
+        return [AsyncScenario(self._client, item.id) for item in page.scenarios]
 
 
 class AsyncBenchmarkOps:
@@ -920,8 +920,8 @@ async def list(self, **params: Unpack[SDKNetworkPolicyListParams]) -> list[Async
         :return: List of network policies
         :rtype: list[AsyncNetworkPolicy]
         """
-        page = self._client.network_policies.list(**params)
-        return [AsyncNetworkPolicy(self._client, item.id) async for item in page]
+        page = await self._client.network_policies.list(**params)
+        return [AsyncNetworkPolicy(self._client, item.id) for item in page.network_policies]
 
 
 class AsyncRunloopSDK:

src/runloop_api_client/sdk/sync.py

@@ -552,7 +552,7 @@ def list(self, **params: Unpack[SDKScorerListParams]) -> list[Scorer]:
         :rtype: list[Scorer]
         """
         page = self._client.scenarios.scorers.list(**params)
-        return [Scorer(self._client, item.id) for item in page]
+        return [Scorer(self._client, item.id) for item in page.scorers]
 
 
 class AgentOps:
@@ -843,7 +843,7 @@ def list(self, **params: Unpack[SDKScenarioListParams]) -> list[Scenario]:
         :rtype: list[Scenario]
         """
         page = self._client.scenarios.list(**params)
-        return [Scenario(self._client, item.id) for item in page]
+        return [Scenario(self._client, item.id) for item in page.scenarios]
 
 
 class BenchmarkOps:
@@ -946,7 +946,7 @@ def list(self, **params: Unpack[SDKNetworkPolicyListParams]) -> list[NetworkPoli
         :rtype: list[NetworkPolicy]
         """
         page = self._client.network_policies.list(**params)
-        return [NetworkPolicy(self._client, item.id) for item in page]
+        return [NetworkPolicy(self._client, item.id) for item in page.network_policies]
 
 
 class RunloopSDK:

tests/sdk/test_async_ops.py

@@ -732,12 +732,8 @@ def test_from_id(self, mock_async_client: AsyncMock) -> None:
     @pytest.mark.asyncio
     async def test_list_empty(self, mock_async_client: AsyncMock) -> None:
         """Test list method with empty results."""
-
-        async def async_iter():
-            return
-            yield  # Make this a generator
-
-        mock_async_client.scenarios.scorers.list = AsyncMock(return_value=async_iter())
+        page = SimpleNamespace(scorers=[])
+        mock_async_client.scenarios.scorers.list = AsyncMock(return_value=page)
 
         ops = AsyncScorerOps(mock_async_client)
         scorers = await ops.list(limit=10)
@@ -748,11 +744,8 @@ async def async_iter():
     @pytest.mark.asyncio
     async def test_list_single(self, mock_async_client: AsyncMock, scorer_view: MockScorerView) -> None:
         """Test list method with single result."""
-
-        async def async_iter():
-            yield scorer_view
-
-        mock_async_client.scenarios.scorers.list = AsyncMock(return_value=async_iter())
+        page = SimpleNamespace(scorers=[scorer_view])
+        mock_async_client.scenarios.scorers.list = AsyncMock(return_value=page)
 
         ops = AsyncScorerOps(mock_async_client)
         scorers = await ops.list(
@@ -770,12 +763,8 @@ async def test_list_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list method with multiple results."""
         scorer_view1 = MockScorerView(id="scorer_001", type="scorer-1")
         scorer_view2 = MockScorerView(id="scorer_002", type="scorer-2")
-
-        async def async_iter():
-            yield scorer_view1
-            yield scorer_view2
-
-        mock_async_client.scenarios.scorers.list = AsyncMock(return_value=async_iter())
+        page = SimpleNamespace(scorers=[scorer_view1, scorer_view2])
+        mock_async_client.scenarios.scorers.list = AsyncMock(return_value=page)
 
         ops = AsyncScorerOps(mock_async_client)
         scorers = await ops.list(limit=10)
@@ -1152,12 +1141,8 @@ def test_from_id(self, mock_async_client: AsyncMock) -> None:
     @pytest.mark.asyncio
     async def test_list_empty(self, mock_async_client: AsyncMock) -> None:
         """Test list method with empty results."""
-
-        async def async_iter():
-            return
-            yield  # Make this a generator
-
-        mock_async_client.scenarios.list = AsyncMock(return_value=async_iter())
+        page = SimpleNamespace(scenarios=[])
+        mock_async_client.scenarios.list = AsyncMock(return_value=page)
 
         ops = AsyncScenarioOps(mock_async_client)
         scenarios = await ops.list(limit=10)
@@ -1168,11 +1153,8 @@ async def async_iter():
     @pytest.mark.asyncio
     async def test_list_single(self, mock_async_client: AsyncMock, scenario_view: MockScenarioView) -> None:
         """Test list method with single result."""
-
-        async def async_iter():
-            yield scenario_view
-
-        mock_async_client.scenarios.list = AsyncMock(return_value=async_iter())
+        page = SimpleNamespace(scenarios=[scenario_view])
+        mock_async_client.scenarios.list = AsyncMock(return_value=page)
 
         ops = AsyncScenarioOps(mock_async_client)
         scenarios = await ops.list(limit=10)
@@ -1185,15 +1167,10 @@ async def async_iter():
     @pytest.mark.asyncio
     async def test_list_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list method with multiple results."""
-
         scenario_view1 = MockScenarioView(id="scn_001", name="scenario-1")
         scenario_view2 = MockScenarioView(id="scn_002", name="scenario-2")
-
-        async def async_iter():
-            yield scenario_view1
-            yield scenario_view2
-
-        mock_async_client.scenarios.list = AsyncMock(return_value=async_iter())
+        page = SimpleNamespace(scenarios=[scenario_view1, scenario_view2])
+        mock_async_client.scenarios.list = AsyncMock(return_value=page)
 
         ops = AsyncScenarioOps(mock_async_client)
         scenarios = await ops.list(limit=10)
@@ -1291,26 +1268,20 @@ def test_from_id(self, mock_async_client: AsyncMock) -> None:
     @pytest.mark.asyncio
     async def test_list_empty(self, mock_async_client: AsyncMock) -> None:
         """Test list method with empty results."""
-
-        async def async_iter():
-            return
-            yield  # Make this a generator
-
-        mock_async_client.network_policies.list.return_value = async_iter()
+        page = SimpleNamespace(network_policies=[])
+        mock_async_client.network_policies.list = AsyncMock(return_value=page)
 
         ops = AsyncNetworkPolicyOps(mock_async_client)
         network_policies = await ops.list(limit=10)
 
         assert len(network_policies) == 0
+        mock_async_client.network_policies.list.assert_awaited_once()
 
     @pytest.mark.asyncio
     async def test_list_single(self, mock_async_client: AsyncMock, network_policy_view: MockNetworkPolicyView) -> None:
         """Test list method with single result."""
-
-        async def async_iter():
-            yield network_policy_view
-
-        mock_async_client.network_policies.list.return_value = async_iter()
+        page = SimpleNamespace(network_policies=[network_policy_view])
+        mock_async_client.network_policies.list = AsyncMock(return_value=page)
 
         ops = AsyncNetworkPolicyOps(mock_async_client)
         network_policies = await ops.list(
@@ -1321,18 +1292,15 @@ async def async_iter():
         assert len(network_policies) == 1
         assert isinstance(network_policies[0], AsyncNetworkPolicy)
         assert network_policies[0].id == "np_123"
+        mock_async_client.network_policies.list.assert_awaited_once()
 
     @pytest.mark.asyncio
     async def test_list_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list method with multiple results."""
         network_policy_view1 = MockNetworkPolicyView(id="np_001", name="policy-1")
         network_policy_view2 = MockNetworkPolicyView(id="np_002", name="policy-2")
-
-        async def async_iter():
-            yield network_policy_view1
-            yield network_policy_view2
-
-        mock_async_client.network_policies.list.return_value = async_iter()
+        page = SimpleNamespace(network_policies=[network_policy_view1, network_policy_view2])
+        mock_async_client.network_policies.list = AsyncMock(return_value=page)
 
         ops = AsyncNetworkPolicyOps(mock_async_client)
         network_policies = await ops.list(limit=10)
@@ -1342,6 +1310,7 @@ async def async_iter():
         assert isinstance(network_policies[1], AsyncNetworkPolicy)
         assert network_policies[0].id == "np_001"
         assert network_policies[1].id == "np_002"
+        mock_async_client.network_policies.list.assert_awaited_once()
 
 
 class TestAsyncRunloopSDK:

tests/sdk/test_ops.py

@@ -679,7 +679,8 @@ def test_from_id(self, mock_client: Mock) -> None:
 
     def test_list_empty(self, mock_client: Mock) -> None:
         """Test list method with empty results."""
-        mock_client.scenarios.scorers.list.return_value = []
+        page = SimpleNamespace(scorers=[])
+        mock_client.scenarios.scorers.list.return_value = page
 
         ops = ScorerOps(mock_client)
         scorers = ops.list(limit=10)
@@ -689,7 +690,8 @@ def test_list_empty(self, mock_client: Mock) -> None:
 
     def test_list_single(self, mock_client: Mock, scorer_view: MockScorerView) -> None:
         """Test list method with single result."""
-        mock_client.scenarios.scorers.list.return_value = [scorer_view]
+        page = SimpleNamespace(scorers=[scorer_view])
+        mock_client.scenarios.scorers.list.return_value = page
 
         ops = ScorerOps(mock_client)
         scorers = ops.list(
@@ -706,7 +708,8 @@ def test_list_multiple(self, mock_client: Mock) -> None:
         """Test list method with multiple results."""
         scorer_view1 = MockScorerView(id="scorer_001", type="scorer-1")
         scorer_view2 = MockScorerView(id="scorer_002", type="scorer-2")
-        mock_client.scenarios.scorers.list.return_value = [scorer_view1, scorer_view2]
+        page = SimpleNamespace(scorers=[scorer_view1, scorer_view2])
+        mock_client.scenarios.scorers.list.return_value = page
 
         ops = ScorerOps(mock_client)
         scorers = ops.list(limit=10)
@@ -1062,8 +1065,8 @@ def test_from_id(self, mock_client: Mock) -> None:
 
     def test_list_empty(self, mock_client: Mock) -> None:
         """Test list method with empty results."""
-
-        mock_client.scenarios.list.return_value = []
+        page = SimpleNamespace(scenarios=[])
+        mock_client.scenarios.list.return_value = page
 
         ops = ScenarioOps(mock_client)
         scenarios = ops.list(limit=10)
@@ -1073,8 +1076,8 @@ def test_list_empty(self, mock_client: Mock) -> None:
 
     def test_list_single(self, mock_client: Mock, scenario_view: MockScenarioView) -> None:
         """Test list method with single result."""
-
-        mock_client.scenarios.list.return_value = [scenario_view]
+        page = SimpleNamespace(scenarios=[scenario_view])
+        mock_client.scenarios.list.return_value = page
 
         ops = ScenarioOps(mock_client)
         scenarios = ops.list(limit=10)
@@ -1086,10 +1089,10 @@ def test_list_single(self, mock_client: Mock, scenario_view: MockScenarioView) -
 
     def test_list_multiple(self, mock_client: Mock) -> None:
         """Test list method with multiple results."""
-
         scenario_view1 = MockScenarioView(id="scn_001", name="scenario-1")
         scenario_view2 = MockScenarioView(id="scn_002", name="scenario-2")
-        mock_client.scenarios.list.return_value = [scenario_view1, scenario_view2]
+        page = SimpleNamespace(scenarios=[scenario_view1, scenario_view2])
+        mock_client.scenarios.list.return_value = page
 
         ops = ScenarioOps(mock_client)
         scenarios = ops.list(limit=10)
@@ -1182,7 +1185,8 @@ def test_from_id(self, mock_client: Mock) -> None:
 
     def test_list_empty(self, mock_client: Mock) -> None:
         """Test list method with empty results."""
-        mock_client.network_policies.list.return_value = []
+        page = SimpleNamespace(network_policies=[])
+        mock_client.network_policies.list.return_value = page
 
         ops = NetworkPolicyOps(mock_client)
         network_policies = ops.list(limit=10)
@@ -1192,7 +1196,8 @@ def test_list_empty(self, mock_client: Mock) -> None:
 
     def test_list_single(self, mock_client: Mock, network_policy_view: MockNetworkPolicyView) -> None:
         """Test list method with single result."""
-        mock_client.network_policies.list.return_value = [network_policy_view]
+        page = SimpleNamespace(network_policies=[network_policy_view])
+        mock_client.network_policies.list.return_value = page
 
         ops = NetworkPolicyOps(mock_client)
         network_policies = ops.list(
@@ -1209,7 +1214,8 @@ def test_list_multiple(self, mock_client: Mock) -> None:
         """Test list method with multiple results."""
         network_policy_view1 = MockNetworkPolicyView(id="np_001", name="policy-1")
         network_policy_view2 = MockNetworkPolicyView(id="np_002", name="policy-2")
-        mock_client.network_policies.list.return_value = [network_policy_view1, network_policy_view2]
+        page = SimpleNamespace(network_policies=[network_policy_view1, network_policy_view2])
+        mock_client.network_policies.list.return_value = page
 
         ops = NetworkPolicyOps(mock_client)
         network_policies = ops.list(limit=10)