feat(network-policy): add network policies

src/runloop_api_client/sdk/__init__.py

@@ -14,6 +14,7 @@
     SnapshotOps,
     BenchmarkOps,
     BlueprintOps,
+    NetworkPolicyOps,
     StorageObjectOps,
 )
 from .agent import Agent
@@ -27,6 +28,7 @@
     AsyncSnapshotOps,
     AsyncBenchmarkOps,
     AsyncBlueprintOps,
+    AsyncNetworkPolicyOps,
     AsyncStorageObjectOps,
 )
 from .devbox import Devbox, NamedShell
@@ -43,6 +45,7 @@
 from .benchmark_run import BenchmarkRun
 from .async_scenario import AsyncScenario
 from .async_snapshot import AsyncSnapshot
+from .network_policy import NetworkPolicy
 from .storage_object import StorageObject
 from .async_benchmark import AsyncBenchmark
 from .async_blueprint import AsyncBlueprint
@@ -51,6 +54,7 @@
 from .scenario_builder import ScenarioBuilder
 from .async_scenario_run import AsyncScenarioRun
 from .async_benchmark_run import AsyncBenchmarkRun
+from .async_network_policy import AsyncNetworkPolicy
 from .async_storage_object import AsyncStorageObject
 from .async_execution_result import AsyncExecutionResult
 from .async_scenario_builder import AsyncScenarioBuilder
@@ -76,6 +80,8 @@
     "AsyncSnapshotOps",
     "StorageObjectOps",
     "AsyncStorageObjectOps",
+    "NetworkPolicyOps",
+    "AsyncNetworkPolicyOps",
     # Resource classes
     "Agent",
     "AsyncAgent",
@@ -104,6 +110,8 @@
     "AsyncSnapshot",
     "StorageObject",
     "AsyncStorageObject",
+    "NetworkPolicy",
+    "AsyncNetworkPolicy",
     "NamedShell",
     "AsyncNamedShell",
 ]

src/runloop_api_client/sdk/_types.py

@@ -19,10 +19,13 @@
     BenchmarkUpdateParams,
     BlueprintCreateParams,
     DevboxUploadFileParams,
+    NetworkPolicyListParams,
     DevboxCreateTunnelParams,
     DevboxDownloadFileParams,
     DevboxRemoveTunnelParams,
     DevboxSnapshotDiskParams,
+    NetworkPolicyCreateParams,
+    NetworkPolicyUpdateParams,
     DevboxReadFileContentsParams,
     DevboxWriteFileContentsParams,
 )
@@ -236,3 +239,15 @@ class SDKBenchmarkListRunsParams(RunSelfListParams, BaseRequestOptions):
 
 class SDKBenchmarkRunListScenarioRunsParams(RunListScenarioRunsParams, BaseRequestOptions):
     pass
+
+
+class SDKNetworkPolicyCreateParams(NetworkPolicyCreateParams, LongRequestOptions):
+    pass
+
+
+class SDKNetworkPolicyListParams(NetworkPolicyListParams, BaseRequestOptions):
+    pass
+
+
+class SDKNetworkPolicyUpdateParams(NetworkPolicyUpdateParams, LongRequestOptions):
+    pass

src/runloop_api_client/sdk/async_.py

@@ -26,6 +26,8 @@
     SDKBenchmarkCreateParams,
     SDKBlueprintCreateParams,
     SDKDiskSnapshotListParams,
+    SDKNetworkPolicyListParams,
+    SDKNetworkPolicyCreateParams,
     SDKDevboxCreateFromImageParams,
 )
 from .._types import Timeout, NotGiven, not_given
@@ -39,6 +41,7 @@
 from .async_benchmark import AsyncBenchmark
 from .async_blueprint import AsyncBlueprint
 from ..lib.context_loader import TarFilter, build_directory_tar
+from .async_network_policy import AsyncNetworkPolicy
 from .async_storage_object import AsyncStorageObject
 from .async_scenario_builder import AsyncScenarioBuilder
 from ..types.object_create_params import ContentType
@@ -867,6 +870,60 @@ async def list(self, **params: Unpack[SDKBenchmarkListParams]) -> list[AsyncBenc
         return [AsyncBenchmark(self._client, item.id) for item in page.benchmarks]
 
 
+class AsyncNetworkPolicyOps:
+    """High-level async manager for creating and managing network policies.
+
+    Accessed via ``runloop.network_policy`` from :class:`AsyncRunloopSDK`, provides
+    coroutines to create, retrieve, update, delete, and list network policies.
+
+    Example:
+        >>> runloop = AsyncRunloopSDK()
+        >>> policy = await runloop.network_policy.create(
+        ...     name="my-policy",
+        ...     allowed_hostnames=["github.com", "*.npmjs.org"],
+        ... )
+        >>> policies = await runloop.network_policy.list()
+    """
+
+    def __init__(self, client: AsyncRunloop) -> None:
+        """Initialize AsyncNetworkPolicyOps.
+
+        :param client: AsyncRunloop client instance
+        :type client: AsyncRunloop
+        """
+        self._client = client
+
+    async def create(self, **params: Unpack[SDKNetworkPolicyCreateParams]) -> AsyncNetworkPolicy:
+        """Create a new network policy.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKNetworkPolicyCreateParams` for available parameters
+        :return: The newly created network policy
+        :rtype: AsyncNetworkPolicy
+        """
+        response = await self._client.network_policies.create(**params)
+        return AsyncNetworkPolicy(self._client, response.id)
+
+    def from_id(self, network_policy_id: str) -> AsyncNetworkPolicy:
+        """Get an AsyncNetworkPolicy instance for an existing network policy ID.
+
+        :param network_policy_id: ID of the network policy
+        :type network_policy_id: str
+        :return: AsyncNetworkPolicy instance for the given ID
+        :rtype: AsyncNetworkPolicy
+        """
+        return AsyncNetworkPolicy(self._client, network_policy_id)
+
+    async def list(self, **params: Unpack[SDKNetworkPolicyListParams]) -> list[AsyncNetworkPolicy]:
+        """List all network policies, optionally filtered by parameters.
+
+        :param params: See :typeddict:`~runloop_api_client.sdk._types.SDKNetworkPolicyListParams` for available parameters
+        :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]
+
+
 class AsyncRunloopSDK:
     """High-level asynchronous entry point for the Runloop SDK.
 
@@ -892,6 +949,8 @@ class AsyncRunloopSDK:
     :vartype snapshot: AsyncSnapshotOps
     :ivar storage_object: High-level async interface for storage object management
     :vartype storage_object: AsyncStorageObjectOps
+    :ivar network_policy: High-level async interface for network policy management
+    :vartype network_policy: AsyncNetworkPolicyOps
 
     Example:
         >>> runloop = AsyncRunloopSDK()  # Uses RUNLOOP_API_KEY env var
@@ -906,6 +965,7 @@ class AsyncRunloopSDK:
     benchmark: AsyncBenchmarkOps
     devbox: AsyncDevboxOps
     blueprint: AsyncBlueprintOps
+    network_policy: AsyncNetworkPolicyOps
     scenario: AsyncScenarioOps
     scorer: AsyncScorerOps
     snapshot: AsyncSnapshotOps
@@ -953,6 +1013,7 @@ def __init__(
         self.benchmark = AsyncBenchmarkOps(self.api)
         self.devbox = AsyncDevboxOps(self.api)
         self.blueprint = AsyncBlueprintOps(self.api)
+        self.network_policy = AsyncNetworkPolicyOps(self.api)
         self.scenario = AsyncScenarioOps(self.api)
         self.scorer = AsyncScorerOps(self.api)
         self.snapshot = AsyncSnapshotOps(self.api)

src/runloop_api_client/sdk/async_benchmark.py

@@ -163,7 +163,5 @@ async def list_runs(
             **params,
         )
         return [
-            AsyncBenchmarkRun(self._client, run.id, run.benchmark_id)
-            for run in page.runs
-            if run.benchmark_id is not None
+            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_network_policy.py

@@ -0,0 +1,109 @@
+"""NetworkPolicy resource class for asynchronous operations."""
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Unpack, override
+
+from ._types import BaseRequestOptions, LongRequestOptions
+from .._types import SequenceNotStr
+from .._client import AsyncRunloop
+from ..types.network_policy_view import NetworkPolicyView
+
+
+class AsyncNetworkPolicy:
+    """Asynchronous wrapper around a network policy resource."""
+
+    def __init__(
+        self,
+        client: AsyncRunloop,
+        network_policy_id: str,
+    ) -> None:
+        """Initialize the wrapper.
+
+        :param client: Generated AsyncRunloop client
+        :type client: AsyncRunloop
+        :param network_policy_id: NetworkPolicy ID returned by the API
+        :type network_policy_id: str
+        """
+        self._client = client
+        self._id = network_policy_id
+
+    @override
+    def __repr__(self) -> str:
+        return f"<AsyncNetworkPolicy id={self._id!r}>"
+
+    @property
+    def id(self) -> str:
+        """Return the network policy ID.
+
+        :return: Unique network policy ID
+        :rtype: str
+        """
+        return self._id
+
+    async def get_info(
+        self,
+        **options: Unpack[BaseRequestOptions],
+    ) -> NetworkPolicyView:
+        """Retrieve the latest network policy details.
+
+        :param options: Optional request configuration
+        :return: API response describing the network policy
+        :rtype: NetworkPolicyView
+        """
+        return await self._client.network_policies.retrieve(
+            self._id,
+            **options,
+        )
+
+    async def update(
+        self,
+        *,
+        allow_all: Optional[bool] = None,
+        allow_devbox_to_devbox: Optional[bool] = None,
+        allowed_hostnames: Optional[SequenceNotStr[str]] = None,
+        description: Optional[str] = None,
+        name: Optional[str] = None,
+        **options: Unpack[LongRequestOptions],
+    ) -> NetworkPolicyView:
+        """Update the network policy.
+
+        :param allow_all: If true, all egress traffic is allowed (ALLOW_ALL policy)
+        :type allow_all: Optional[bool]
+        :param allow_devbox_to_devbox: If true, allows traffic between devboxes via tunnels
+        :type allow_devbox_to_devbox: Optional[bool]
+        :param allowed_hostnames: DNS-based allow list with wildcard support
+        :type allowed_hostnames: Optional[SequenceNotStr[str]]
+        :param description: Updated description for the NetworkPolicy
+        :type description: Optional[str]
+        :param name: Updated human-readable name for the NetworkPolicy
+        :type name: Optional[str]
+        :param options: Optional long-running request configuration
+        :return: Updated network policy view
+        :rtype: NetworkPolicyView
+        """
+        return await self._client.network_policies.update(
+            self._id,
+            allow_all=allow_all,
+            allow_devbox_to_devbox=allow_devbox_to_devbox,
+            allowed_hostnames=allowed_hostnames,
+            description=description,
+            name=name,
+            **options,
+        )
+
+    async def delete(
+        self,
+        **options: Unpack[LongRequestOptions],
+    ) -> NetworkPolicyView:
+        """Delete the network policy.
+
+        :param options: Optional long-running request configuration
+        :return: API response acknowledging deletion
+        :rtype: NetworkPolicyView
+        """
+        return await self._client.network_policies.delete(
+            self._id,
+            **options,
+        )

src/runloop_api_client/sdk/benchmark.py

@@ -163,7 +163,5 @@ def list_runs(
             **params,
         )
         return [
-            BenchmarkRun(self._client, run.id, run.benchmark_id)
-            for run in page.runs
-            if run.benchmark_id is not None
+            BenchmarkRun(self._client, run.id, run.benchmark_id) for run in page.runs if run.benchmark_id is not None
         ]