runloop_api_client 1.5.1__py3-none-any.whl

runloop_api_client/sdk/async_agent.py

@@ -0,0 +1,70 @@
+"""Agent resource class for asynchronous operations."""
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Unpack, override
+
+from ._types import (
+    BaseRequestOptions,
+)
+from .._client import AsyncRunloop
+from ..types.agent_view import AgentView
+
+
+class AsyncAgent:
+    """Async wrapper around agent operations.
+
+    This class provides an asynchronous interface for interacting with agents,
+    including retrieving agent information.
+
+    Example:
+        >>> agent = await runloop.agent.create_from_npm(name="my-agent", package_name="@runloop/example-agent")
+        >>> info = await agent.get_info()
+        >>> print(info.name)
+    """
+
+    def __init__(
+        self,
+        client: AsyncRunloop,
+        agent_id: str,
+        agent_view: Optional[AgentView] = None,
+    ) -> None:
+        """Initialize the wrapper.
+
+        :param client: Generated AsyncRunloop client
+        :type client: AsyncRunloop
+        :param agent_id: Agent identifier returned by the API
+        :type agent_id: str
+        """
+        self._client = client
+        self._id = agent_id
+        self._agent_view = agent_view
+
+    @override
+    def __repr__(self) -> str:
+        return f"<AsyncAgent id={self._id!r}>"
+
+    @property
+    def id(self) -> str:
+        """Return the agent identifier.
+
+        :return: Unique agent ID
+        :rtype: str
+        """
+        return self._id
+
+    async def get_info(
+        self,
+        **options: Unpack[BaseRequestOptions],
+    ) -> AgentView:
+        """Retrieve the latest agent information.
+
+        :param options: Optional request configuration
+        :return: Agent details
+        :rtype: AgentView
+        """
+        return await self._client.agents.retrieve(
+            self._id,
+            **options,
+        )

runloop_api_client/sdk/async_benchmark.py

@@ -0,0 +1,169 @@
+"""AsyncBenchmark resource class for asynchronous operations."""
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Unpack, override
+
+from ..types import BenchmarkView
+from ._types import (
+    BaseRequestOptions,
+    LongRequestOptions,
+    SDKBenchmarkUpdateParams,
+    SDKBenchmarkListRunsParams,
+    SDKBenchmarkStartRunParams,
+)
+from .._types import SequenceNotStr
+from .._client import AsyncRunloop
+from .async_benchmark_run import AsyncBenchmarkRun
+
+
+class AsyncBenchmark:
+    """A benchmark for evaluating agent performance across scenarios (async).
+
+    Provides async methods for retrieving benchmark details, updating the benchmark,
+    managing scenarios, and starting benchmark runs. Obtain instances via
+    ``runloop.benchmark.from_id()`` or ``runloop.benchmark.list()``.
+
+    Example:
+        >>> benchmark = runloop.benchmark.from_id("bmd_xxx")
+        >>> info = await benchmark.get_info()
+        >>> run = await benchmark.start_run(run_name="evaluation-v1")
+        >>> for scenario_id in info.scenario_ids:
+        ...     scenario = await runloop.scenario.from_id(scenario_id)
+        ...     scenario_run = await scenario.run(benchmark_run_id=run.id, run_name="evaluation-v1")
+    """
+
+    def __init__(self, client: AsyncRunloop, benchmark_id: str) -> None:
+        """Create an AsyncBenchmark instance.
+
+        :param client: AsyncRunloop client instance
+        :type client: AsyncRunloop
+        :param benchmark_id: Benchmark ID
+        :type benchmark_id: str
+        """
+        self._client = client
+        self._id = benchmark_id
+
+    @override
+    def __repr__(self) -> str:
+        return f"<AsyncBenchmark id={self._id!r}>"
+
+    @property
+    def id(self) -> str:
+        """Return the benchmark ID.
+
+        :return: Unique benchmark ID
+        :rtype: str
+        """
+        return self._id
+
+    async def get_info(
+        self,
+        **options: Unpack[BaseRequestOptions],
+    ) -> BenchmarkView:
+        """Retrieve current benchmark details.
+
+        :param options: See :typeddict:`~runloop_api_client.sdk._types.BaseRequestOptions` for available options
+        :return: Current benchmark info
+        :rtype: BenchmarkView
+        """
+        return await self._client.benchmarks.retrieve(
+            self._id,
+            **options,
+        )
+
+    async def update(
+        self,
+        **params: Unpack[SDKBenchmarkUpdateParams],
+    ) -> BenchmarkView:
+        """Update the benchmark.
+
+        Only provided fields will be updated.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKBenchmarkUpdateParams` for available parameters
+        :return: Updated benchmark info
+        :rtype: BenchmarkView
+        """
+        return await self._client.benchmarks.update(
+            self._id,
+            **params,
+        )
+
+    async def start_run(
+        self,
+        **params: Unpack[SDKBenchmarkStartRunParams],
+    ) -> AsyncBenchmarkRun:
+        """Start a new benchmark run.
+
+        Creates a new benchmark run and returns an AsyncBenchmarkRun instance for
+        managing the run lifecycle.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKBenchmarkStartRunParams` for available parameters
+        :return: AsyncBenchmarkRun instance for managing the run
+        :rtype: AsyncBenchmarkRun
+        """
+        run_view = await self._client.benchmarks.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(
+        self,
+        scenario_ids: SequenceNotStr[str],
+        **options: Unpack[LongRequestOptions],
+    ) -> BenchmarkView:
+        """Add scenarios to the benchmark.
+
+        :param scenario_ids: List of scenario IDs to add
+        :type scenario_ids: SequenceNotStr[str]
+        :param options: See :typeddict:`~runloop_api_client.sdk._types.LongRequestOptions` for available options
+        :return: Updated benchmark info
+        :rtype: BenchmarkView
+        """
+        return await self._client.benchmarks.update_scenarios(
+            self._id,
+            scenarios_to_add=scenario_ids,
+            **options,
+        )
+
+    async def remove_scenarios(
+        self,
+        scenario_ids: SequenceNotStr[str],
+        **options: Unpack[LongRequestOptions],
+    ) -> BenchmarkView:
+        """Remove scenarios from the benchmark.
+
+        :param scenario_ids: List of scenario IDs to remove
+        :type scenario_ids: SequenceNotStr[str]
+        :param options: See :typeddict:`~runloop_api_client.sdk._types.LongRequestOptions` for available options
+        :return: Updated benchmark info
+        :rtype: BenchmarkView
+        """
+        return await self._client.benchmarks.update_scenarios(
+            self._id,
+            scenarios_to_remove=scenario_ids,
+            **options,
+        )
+
+    async def list_runs(
+        self,
+        **params: Unpack[SDKBenchmarkListRunsParams],
+    ) -> List[AsyncBenchmarkRun]:
+        """List all runs for this benchmark.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKBenchmarkListRunsParams` for available parameters
+        :return: List of async benchmark runs
+        :rtype: List[AsyncBenchmarkRun]
+        """
+        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
+            if run.benchmark_id is not None
+        ]

runloop_api_client/sdk/async_benchmark_run.py

@@ -0,0 +1,127 @@
+"""AsyncBenchmarkRun resource class for asynchronous operations."""
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Unpack, override
+
+from ..types import BenchmarkRunView
+from ._types import BaseRequestOptions, LongRequestOptions, SDKBenchmarkRunListScenarioRunsParams
+from .._client import AsyncRunloop
+from .async_scenario_run import AsyncScenarioRun
+
+
+class AsyncBenchmarkRun:
+    """A benchmark run for evaluating agent performance across scenarios (async).
+
+    Provides async methods for monitoring run status, managing the run lifecycle,
+    and accessing scenario run results. Obtain instances via
+    ``benchmark.start_run()`` or ``benchmark.list_runs()``.
+
+    Example:
+        >>> benchmark = runloop.benchmark.from_id("bench-xxx")
+        >>> run = await benchmark.start_run(run_name="evaluation-v1")
+        >>> info = await run.get_info()
+        >>> scenario_runs = await run.list_scenario_runs()
+    """
+
+    def __init__(self, client: AsyncRunloop, run_id: str, benchmark_id: str) -> None:
+        """Create an AsyncBenchmarkRun instance.
+
+        :param client: AsyncRunloop client instance
+        :type client: AsyncRunloop
+        :param run_id: Benchmark run ID
+        :type run_id: str
+        :param benchmark_id: Parent benchmark ID
+        :type benchmark_id: str
+        """
+        self._client = client
+        self._id = run_id
+        self._benchmark_id = benchmark_id
+
+    @override
+    def __repr__(self) -> str:
+        return f"<AsyncBenchmarkRun id={self._id!r}>"
+
+    @property
+    def id(self) -> str:
+        """Return the benchmark run ID.
+
+        :return: Unique benchmark run ID
+        :rtype: str
+        """
+        return self._id
+
+    @property
+    def benchmark_id(self) -> str:
+        """Return the parent benchmark ID.
+
+        :return: Parent benchmark ID
+        :rtype: str
+        """
+        return self._benchmark_id
+
+    async def get_info(
+        self,
+        **options: Unpack[BaseRequestOptions],
+    ) -> BenchmarkRunView:
+        """Retrieve current benchmark run status and metadata.
+
+        :param options: See :typeddict:`~runloop_api_client.sdk._types.BaseRequestOptions` for available options
+        :return: Current benchmark run state info
+        :rtype: BenchmarkRunView
+        """
+        return await self._client.benchmark_runs.retrieve(
+            self._id,
+            **options,
+        )
+
+    async def cancel(
+        self,
+        **options: Unpack[LongRequestOptions],
+    ) -> BenchmarkRunView:
+        """Cancel the benchmark run.
+
+        Stops all running scenarios and marks the run as canceled.
+
+        :param options: See :typeddict:`~runloop_api_client.sdk._types.LongRequestOptions` for available options
+        :return: Updated benchmark run state
+        :rtype: BenchmarkRunView
+        """
+        return await self._client.benchmark_runs.cancel(
+            self._id,
+            **options,
+        )
+
+    async def complete(
+        self,
+        **options: Unpack[LongRequestOptions],
+    ) -> BenchmarkRunView:
+        """Complete the benchmark run.
+
+        Marks the run as completed. Call this after all scenarios have finished.
+
+        :param options: See :typeddict:`~runloop_api_client.sdk._types.LongRequestOptions` for available options
+        :return: Completed benchmark run state
+        :rtype: BenchmarkRunView
+        """
+        return await self._client.benchmark_runs.complete(
+            self._id,
+            **options,
+        )
+
+    async def list_scenario_runs(
+        self,
+        **params: Unpack[SDKBenchmarkRunListScenarioRunsParams],
+    ) -> List[AsyncScenarioRun]:
+        """List all scenario runs for this benchmark run.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKBenchmarkRunListScenarioRunsParams` for available parameters
+        :return: List of async scenario run objects
+        :rtype: List[AsyncScenarioRun]
+        """
+        page = await self._client.benchmark_runs.list_scenario_runs(
+            self._id,
+            **params,
+        )
+        return [AsyncScenarioRun(self._client, run.id, run.devbox_id) for run in page.runs]

runloop_api_client/sdk/async_blueprint.py

@@ -0,0 +1,104 @@
+"""Blueprint resource class for asynchronous operations."""
+
+from __future__ import annotations
+
+from typing_extensions import Unpack, override
+
+from ..types import BlueprintView
+from ._types import BaseRequestOptions, LongRequestOptions, SDKDevboxCreateFromImageParams
+from .._client import AsyncRunloop
+from .async_devbox import AsyncDevbox
+from ..types.blueprint_build_logs_list_view import BlueprintBuildLogsListView
+
+
+class AsyncBlueprint:
+    """Asynchronous wrapper around a blueprint resource."""
+
+    def __init__(
+        self,
+        client: AsyncRunloop,
+        blueprint_id: str,
+    ) -> None:
+        """Initialize the wrapper.
+
+        :param client: Generated AsyncRunloop client
+        :type client: AsyncRunloop
+        :param blueprint_id: Blueprint ID returned by the API
+        :type blueprint_id: str
+        """
+        self._client = client
+        self._id = blueprint_id
+
+    @override
+    def __repr__(self) -> str:
+        return f"<AsyncBlueprint id={self._id!r}>"
+
+    @property
+    def id(self) -> str:
+        """Return the blueprint ID.
+
+        :return: Unique blueprint ID
+        :rtype: str
+        """
+        return self._id
+
+    async def get_info(
+        self,
+        **options: Unpack[BaseRequestOptions],
+    ) -> BlueprintView:
+        """Retrieve the latest blueprint details.
+
+        :param options: Optional request configuration
+        :return: API response describing the blueprint
+        :rtype: BlueprintView
+        """
+        return await self._client.blueprints.retrieve(
+            self._id,
+            **options,
+        )
+
+    async def logs(
+        self,
+        **options: Unpack[BaseRequestOptions],
+    ) -> BlueprintBuildLogsListView:
+        """Retrieve build logs for the blueprint.
+
+        :param options: Optional request configuration
+        :return: Log entries for the most recent build
+        :rtype: BlueprintBuildLogsListView
+        """
+        return await self._client.blueprints.logs(
+            self._id,
+            **options,
+        )
+
+    async def delete(
+        self,
+        **options: Unpack[LongRequestOptions],
+    ) -> object:
+        """Delete the blueprint.
+
+        :param options: Optional long-running request configuration
+        :return: API response acknowledging deletion
+        :rtype: object
+        """
+        return await self._client.blueprints.delete(
+            self._id,
+            **options,
+        )
+
+    async def create_devbox(
+        self,
+        **params: Unpack[SDKDevboxCreateFromImageParams],
+    ) -> "AsyncDevbox":
+        """Create a devbox derived from the blueprint.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKDevboxCreateFromImageParams` for available parameters
+        :return: Wrapper bound to the running devbox
+        :rtype: AsyncDevbox
+        """
+        devbox_view = await self._client.devboxes.create_and_await_running(
+            blueprint_id=self._id,
+            **params,
+        )
+        return AsyncDevbox(self._client, devbox_view.id)