Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

Add missing files

Jakub Novak4b5d17e8a404
diff --git a/.gitignore b/.gitignore
index 74d83b006..f88780942 100644
--- a/.gitignore
+++ b/.gitignore
@@ -292,3 +292,4 @@ cython_debug/
# SDK reference artifacts
sdk_ref/
sdkRefRoutes.json
+spec/openapi_generated.yml
\ No newline at end of file
diff --git a/packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_sandbox_id.py b/packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_sandbox_id.py
new file mode 100644
index 000000000..7ab59ee7e
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/api/sandboxes/get_sandboxes_sandbox_id.py
@@ -0,0 +1,159 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.running_sandbox import RunningSandbox
+from ...types import Response
+
+
+def _get_kwargs(
+ sandbox_id: str,
+) -> Dict[str, Any]:
+ _kwargs: Dict[str, Any] = {
+ "method": "get",
+ "url": f"/sandboxes/{sandbox_id}",
+ }
+
+ return _kwargs
+
+
+def _parse_response(
+ *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, RunningSandbox]]:
+ if response.status_code == HTTPStatus.OK:
+ response_200 = RunningSandbox.from_dict(response.json())
+
+ return response_200
+ if response.status_code == HTTPStatus.UNAUTHORIZED:
+ response_401 = cast(Any, None)
+ return response_401
+ if response.status_code == HTTPStatus.NOT_FOUND:
+ response_404 = cast(Any, None)
+ return response_404
+ if response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+ response_500 = cast(Any, None)
+ return response_500
+ if client.raise_on_unexpected_status:
+ raise errors.UnexpectedStatus(response.status_code, response.content)
+ else:
+ return None
+
+
+def _build_response(
+ *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, RunningSandbox]]:
+ return Response(
+ status_code=HTTPStatus(response.status_code),
+ content=response.content,
+ headers=response.headers,
+ parsed=_parse_response(client=client, response=response),
+ )
+
+
+def sync_detailed(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+) -> Response[Union[Any, RunningSandbox]]:
+ """Get a sandbox by id
+
+ Args:
+ sandbox_id (str):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Response[Union[Any, RunningSandbox]]
+ """
+
+ kwargs = _get_kwargs(
+ sandbox_id=sandbox_id,
+ )
+
+ response = client.get_httpx_client().request(
+ **kwargs,
+ )
+
+ return _build_response(client=client, response=response)
+
+
+def sync(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+) -> Optional[Union[Any, RunningSandbox]]:
+ """Get a sandbox by id
+
+ Args:
+ sandbox_id (str):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Union[Any, RunningSandbox]
+ """
+
+ return sync_detailed(
+ sandbox_id=sandbox_id,
+ client=client,
+ ).parsed
+
+
+async def asyncio_detailed(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+) -> Response[Union[Any, RunningSandbox]]:
+ """Get a sandbox by id
+
+ Args:
+ sandbox_id (str):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Response[Union[Any, RunningSandbox]]
+ """
+
+ kwargs = _get_kwargs(
+ sandbox_id=sandbox_id,
+ )
+
+ response = await client.get_async_httpx_client().request(**kwargs)
+
+ return _build_response(client=client, response=response)
+
+
+async def asyncio(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+) -> Optional[Union[Any, RunningSandbox]]:
+ """Get a sandbox by id
+
+ Args:
+ sandbox_id (str):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Union[Any, RunningSandbox]
+ """
+
+ return (
+ await asyncio_detailed(
+ sandbox_id=sandbox_id,
+ client=client,
+ )
+ ).parsed
diff --git a/packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_pause.py b/packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_pause.py
new file mode 100644
index 000000000..8133ed132
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_pause.py
@@ -0,0 +1,101 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import Response
+
+
+def _get_kwargs(
+ sandbox_id: str,
+) -> Dict[str, Any]:
+ _kwargs: Dict[str, Any] = {
+ "method": "post",
+ "url": f"/sandboxes/{sandbox_id}/pause",
+ }
+
+ return _kwargs
+
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Any]:
+ if response.status_code == HTTPStatus.NO_CONTENT:
+ return None
+ if response.status_code == HTTPStatus.UNAUTHORIZED:
+ return None
+ if response.status_code == HTTPStatus.NOT_FOUND:
+ return None
+ if response.status_code == HTTPStatus.CONFLICT:
+ return None
+ if response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+ return None
+ if client.raise_on_unexpected_status:
+ raise errors.UnexpectedStatus(response.status_code, response.content)
+ else:
+ return None
+
+
+def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]:
+ return Response(
+ status_code=HTTPStatus(response.status_code),
+ content=response.content,
+ headers=response.headers,
+ parsed=_parse_response(client=client, response=response),
+ )
+
+
+def sync_detailed(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+) -> Response[Any]:
+ """Pause the sandbox
+
+ Args:
+ sandbox_id (str):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Response[Any]
+ """
+
+ kwargs = _get_kwargs(
+ sandbox_id=sandbox_id,
+ )
+
+ response = client.get_httpx_client().request(
+ **kwargs,
+ )
+
+ return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+) -> Response[Any]:
+ """Pause the sandbox
+
+ Args:
+ sandbox_id (str):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Response[Any]
+ """
+
+ kwargs = _get_kwargs(
+ sandbox_id=sandbox_id,
+ )
+
+ response = await client.get_async_httpx_client().request(**kwargs)
+
+ return _build_response(client=client, response=response)
diff --git a/packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_resume.py b/packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_resume.py
new file mode 100644
index 000000000..1433aa513
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/api/sandboxes/post_sandboxes_sandbox_id_resume.py
@@ -0,0 +1,185 @@
+from http import HTTPStatus
+from typing import Any, Dict, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.resumed_sandbox import ResumedSandbox
+from ...models.sandbox import Sandbox
+from ...types import Response
+
+
+def _get_kwargs(
+ sandbox_id: str,
+ *,
+ body: ResumedSandbox,
+) -> Dict[str, Any]:
+ headers: Dict[str, Any] = {}
+
+ _kwargs: Dict[str, Any] = {
+ "method": "post",
+ "url": f"/sandboxes/{sandbox_id}/resume",
+ }
+
+ _body = body.to_dict()
+
+ _kwargs["json"] = _body
+ headers["Content-Type"] = "application/json"
+
+ _kwargs["headers"] = headers
+ return _kwargs
+
+
+def _parse_response(
+ *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Sandbox]]:
+ if response.status_code == HTTPStatus.CREATED:
+ response_201 = Sandbox.from_dict(response.json())
+
+ return response_201
+ if response.status_code == HTTPStatus.UNAUTHORIZED:
+ response_401 = cast(Any, None)
+ return response_401
+ if response.status_code == HTTPStatus.NOT_FOUND:
+ response_404 = cast(Any, None)
+ return response_404
+ if response.status_code == HTTPStatus.CONFLICT:
+ response_409 = cast(Any, None)
+ return response_409
+ if response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR:
+ response_500 = cast(Any, None)
+ return response_500
+ if client.raise_on_unexpected_status:
+ raise errors.UnexpectedStatus(response.status_code, response.content)
+ else:
+ return None
+
+
+def _build_response(
+ *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Sandbox]]:
+ return Response(
+ status_code=HTTPStatus(response.status_code),
+ content=response.content,
+ headers=response.headers,
+ parsed=_parse_response(client=client, response=response),
+ )
+
+
+def sync_detailed(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+ body: ResumedSandbox,
+) -> Response[Union[Any, Sandbox]]:
+ """Resume the sandbox
+
+ Args:
+ sandbox_id (str):
+ body (ResumedSandbox):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Response[Union[Any, Sandbox]]
+ """
+
+ kwargs = _get_kwargs(
+ sandbox_id=sandbox_id,
+ body=body,
+ )
+
+ response = client.get_httpx_client().request(
+ **kwargs,
+ )
+
+ return _build_response(client=client, response=response)
+
+
+def sync(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+ body: ResumedSandbox,
+) -> Optional[Union[Any, Sandbox]]:
+ """Resume the sandbox
+
+ Args:
+ sandbox_id (str):
+ body (ResumedSandbox):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Union[Any, Sandbox]
+ """
+
+ return sync_detailed(
+ sandbox_id=sandbox_id,
+ client=client,
+ body=body,
+ ).parsed
+
+
+async def asyncio_detailed(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+ body: ResumedSandbox,
+) -> Response[Union[Any, Sandbox]]:
+ """Resume the sandbox
+
+ Args:
+ sandbox_id (str):
+ body (ResumedSandbox):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Response[Union[Any, Sandbox]]
+ """
+
+ kwargs = _get_kwargs(
+ sandbox_id=sandbox_id,
+ body=body,
+ )
+
+ response = await client.get_async_httpx_client().request(**kwargs)
+
+ return _build_response(client=client, response=response)
+
+
+async def asyncio(
+ sandbox_id: str,
+ *,
+ client: AuthenticatedClient,
+ body: ResumedSandbox,
+) -> Optional[Union[Any, Sandbox]]:
+ """Resume the sandbox
+
+ Args:
+ sandbox_id (str):
+ body (ResumedSandbox):
+
+ Raises:
+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+ httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+ Returns:
+ Union[Any, Sandbox]
+ """
+
+ return (
+ await asyncio_detailed(
+ sandbox_id=sandbox_id,
+ client=client,
+ body=body,
+ )
+ ).parsed
diff --git a/packages/python-sdk/e2b/api/client/models/node.py b/packages/python-sdk/e2b/api/client/models/node.py
new file mode 100644
index 000000000..8c207759f
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/node.py
@@ -0,0 +1,92 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+T = TypeVar("T", bound="Node")
+
+
+@_attrs_define
+class Node:
+ """
+ Attributes:
+ allocated_cpu (int): Number of allocated CPU cores
+ allocated_memory_mi_b (int): Amount of allocated memory in MiB
+ node_id (str): Identifier of the node
+ sandbox_count (int): Number of sandboxes running on the node
+ status (NodeStatus): Status of the node
+ """
+
+ allocated_cpu: int
+ allocated_memory_mi_b: int
+ node_id: str
+ sandbox_count: int
+ status: NodeStatus
+ additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ allocated_cpu = self.allocated_cpu
+
+ allocated_memory_mi_b = self.allocated_memory_mi_b
+
+ node_id = self.node_id
+
+ sandbox_count = self.sandbox_count
+
+ status = self.status.value
+
+ field_dict: Dict[str, Any] = {}
+ field_dict.update(self.additional_properties)
+ field_dict.update(
+ {
+ "allocatedCPU": allocated_cpu,
+ "allocatedMemoryMiB": allocated_memory_mi_b,
+ "nodeID": node_id,
+ "sandboxCount": sandbox_count,
+ "status": status,
+ }
+ )
+
+ return field_dict
+
+ @classmethod
+ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+ d = src_dict.copy()
+ allocated_cpu = d.pop("allocatedCPU")
+
+ allocated_memory_mi_b = d.pop("allocatedMemoryMiB")
+
+ node_id = d.pop("nodeID")
+
+ sandbox_count = d.pop("sandboxCount")
+
+ status = NodeStatus(d.pop("status"))
+
+ node = cls(
+ allocated_cpu=allocated_cpu,
+ allocated_memory_mi_b=allocated_memory_mi_b,
+ node_id=node_id,
+ sandbox_count=sandbox_count,
+ status=status,
+ )
+
+ node.additional_properties = d
+ return node
+
+ @property
+ def additional_keys(self) -> List[str]:
+ return list(self.additional_properties.keys())
+
+ def __getitem__(self, key: str) -> Any:
+ return self.additional_properties[key]
+
+ def __setitem__(self, key: str, value: Any) -> None:
+ self.additional_properties[key] = value
+
+ def __delitem__(self, key: str) -> None:
+ del self.additional_properties[key]
+
+ def __contains__(self, key: str) -> bool:
+ return key in self.additional_properties
diff --git a/packages/python-sdk/e2b/api/client/models/node_detail.py b/packages/python-sdk/e2b/api/client/models/node_detail.py
new file mode 100644
index 000000000..a2326e054
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/node_detail.py
@@ -0,0 +1,98 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+if TYPE_CHECKING:
+ from ..models.running_sandbox import RunningSandbox
+
+
+T = TypeVar("T", bound="NodeDetail")
+
+
+@_attrs_define
+class NodeDetail:
+ """
+ Attributes:
+ cached_builds (List[str]): List of cached builds id on the node
+ node_id (str): Identifier of the node
+ sandboxes (List['RunningSandbox']): List of sandboxes running on the node
+ status (NodeStatus): Status of the node
+ """
+
+ cached_builds: List[str]
+ node_id: str
+ sandboxes: List["RunningSandbox"]
+ status: NodeStatus
+ additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ cached_builds = self.cached_builds
+
+ node_id = self.node_id
+
+ sandboxes = []
+ for sandboxes_item_data in self.sandboxes:
+ sandboxes_item = sandboxes_item_data.to_dict()
+ sandboxes.append(sandboxes_item)
+
+ status = self.status.value
+
+ field_dict: Dict[str, Any] = {}
+ field_dict.update(self.additional_properties)
+ field_dict.update(
+ {
+ "cachedBuilds": cached_builds,
+ "nodeID": node_id,
+ "sandboxes": sandboxes,
+ "status": status,
+ }
+ )
+
+ return field_dict
+
+ @classmethod
+ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+ from ..models.running_sandbox import RunningSandbox
+
+ d = src_dict.copy()
+ cached_builds = cast(List[str], d.pop("cachedBuilds"))
+
+ node_id = d.pop("nodeID")
+
+ sandboxes = []
+ _sandboxes = d.pop("sandboxes")
+ for sandboxes_item_data in _sandboxes:
+ sandboxes_item = RunningSandbox.from_dict(sandboxes_item_data)
+
+ sandboxes.append(sandboxes_item)
+
+ status = NodeStatus(d.pop("status"))
+
+ node_detail = cls(
+ cached_builds=cached_builds,
+ node_id=node_id,
+ sandboxes=sandboxes,
+ status=status,
+ )
+
+ node_detail.additional_properties = d
+ return node_detail
+
+ @property
+ def additional_keys(self) -> List[str]:
+ return list(self.additional_properties.keys())
+
+ def __getitem__(self, key: str) -> Any:
+ return self.additional_properties[key]
+
+ def __setitem__(self, key: str, value: Any) -> None:
+ self.additional_properties[key] = value
+
+ def __delitem__(self, key: str) -> None:
+ del self.additional_properties[key]
+
+ def __contains__(self, key: str) -> bool:
+ return key in self.additional_properties
diff --git a/packages/python-sdk/e2b/api/client/models/node_status.py b/packages/python-sdk/e2b/api/client/models/node_status.py
new file mode 100644
index 000000000..87a77905b
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/node_status.py
@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class NodeStatus(str, Enum):
+ DRAINING = "draining"
+ READY = "ready"
+
+ def __str__(self) -> str:
+ return str(self.value)
diff --git a/packages/python-sdk/e2b/api/client/models/node_status_change.py b/packages/python-sdk/e2b/api/client/models/node_status_change.py
new file mode 100644
index 000000000..43628b809
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/node_status_change.py
@@ -0,0 +1,60 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.node_status import NodeStatus
+
+T = TypeVar("T", bound="NodeStatusChange")
+
+
+@_attrs_define
+class NodeStatusChange:
+ """
+ Attributes:
+ status (NodeStatus): Status of the node
+ """
+
+ status: NodeStatus
+ additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ status = self.status.value
+
+ field_dict: Dict[str, Any] = {}
+ field_dict.update(self.additional_properties)
+ field_dict.update(
+ {
+ "status": status,
+ }
+ )
+
+ return field_dict
+
+ @classmethod
+ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+ d = src_dict.copy()
+ status = NodeStatus(d.pop("status"))
+
+ node_status_change = cls(
+ status=status,
+ )
+
+ node_status_change.additional_properties = d
+ return node_status_change
+
+ @property
+ def additional_keys(self) -> List[str]:
+ return list(self.additional_properties.keys())
+
+ def __getitem__(self, key: str) -> Any:
+ return self.additional_properties[key]
+
+ def __setitem__(self, key: str, value: Any) -> None:
+ self.additional_properties[key] = value
+
+ def __delitem__(self, key: str) -> None:
+ del self.additional_properties[key]
+
+ def __contains__(self, key: str) -> bool:
+ return key in self.additional_properties
diff --git a/packages/python-sdk/e2b/api/client/models/resumed_sandbox.py b/packages/python-sdk/e2b/api/client/models/resumed_sandbox.py
new file mode 100644
index 000000000..ae872a6d1
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/resumed_sandbox.py
@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ResumedSandbox")
+
+
+@_attrs_define
+class ResumedSandbox:
+ """
+ Attributes:
+ timeout (Union[Unset, int]): Time to live for the sandbox in seconds. Default: 15.
+ """
+
+ timeout: Union[Unset, int] = 15
+ additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ timeout = self.timeout
+
+ field_dict: Dict[str, Any] = {}
+ field_dict.update(self.additional_properties)
+ field_dict.update({})
+ if timeout is not UNSET:
+ field_dict["timeout"] = timeout
+
+ return field_dict
+
+ @classmethod
+ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+ d = src_dict.copy()
+ timeout = d.pop("timeout", UNSET)
+
+ resumed_sandbox = cls(
+ timeout=timeout,
+ )
+
+ resumed_sandbox.additional_properties = d
+ return resumed_sandbox
+
+ @property
+ def additional_keys(self) -> List[str]:
+ return list(self.additional_properties.keys())
+
+ def __getitem__(self, key: str) -> Any:
+ return self.additional_properties[key]
+
+ def __setitem__(self, key: str, value: Any) -> None:
+ self.additional_properties[key] = value
+
+ def __delitem__(self, key: str) -> None:
+ del self.additional_properties[key]
+
+ def __contains__(self, key: str) -> bool:
+ return key in self.additional_properties
diff --git a/packages/python-sdk/e2b/api/client/models/team_user.py b/packages/python-sdk/e2b/api/client/models/team_user.py
new file mode 100644
index 000000000..9aa62dfb5
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/team_user.py
@@ -0,0 +1,66 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="TeamUser")
+
+
+@_attrs_define
+class TeamUser:
+ """
+ Attributes:
+ email (str): Email of the user
+ id (str): Identifier of the user
+ """
+
+ email: str
+ id: str
+ additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ email = self.email
+
+ id = self.id
+
+ field_dict: Dict[str, Any] = {}
+ field_dict.update(self.additional_properties)
+ field_dict.update(
+ {
+ "email": email,
+ "id": id,
+ }
+ )
+
+ return field_dict
+
+ @classmethod
+ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+ d = src_dict.copy()
+ email = d.pop("email")
+
+ id = d.pop("id")
+
+ team_user = cls(
+ email=email,
+ id=id,
+ )
+
+ team_user.additional_properties = d
+ return team_user
+
+ @property
+ def additional_keys(self) -> List[str]:
+ return list(self.additional_properties.keys())
+
+ def __getitem__(self, key: str) -> Any:
+ return self.additional_properties[key]
+
+ def __setitem__(self, key: str, value: Any) -> None:
+ self.additional_properties[key] = value
+
+ def __delitem__(self, key: str) -> None:
+ del self.additional_properties[key]
+
+ def __contains__(self, key: str) -> bool:
+ return key in self.additional_properties
diff --git a/packages/python-sdk/e2b/api/client/models/template_update_request.py b/packages/python-sdk/e2b/api/client/models/template_update_request.py
new file mode 100644
index 000000000..66e235c41
--- /dev/null
+++ b/packages/python-sdk/e2b/api/client/models/template_update_request.py
@@ -0,0 +1,58 @@
+from typing import Any, Dict, List, Type, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TemplateUpdateRequest")
+
+
+@_attrs_define
+class TemplateUpdateRequest:
+ """
+ Attributes:
+ public (Union[Unset, bool]): Whether the template is public or only accessible by the team
+ """
+
+ public: Union[Unset, bool] = UNSET
+ additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+ def to_dict(self) -> Dict[str, Any]:
+ public = self.public
+
+ field_dict: Dict[str, Any] = {}
+ field_dict.update(self.additional_properties)
+ field_dict.update({})
+ if public is not UNSET:
+ field_dict["public"] = public
+
+ return field_dict
+
+ @classmethod
+ def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+ d = src_dict.copy()
+ public = d.pop("public", UNSET)
+
+ template_update_request = cls(
+ public=public,
+ )
+
+ template_update_request.additional_properties = d
+ return template_update_request
+
+ @property
+ def additional_keys(self) -> List[str]:
+ return list(self.additional_properties.keys())
+
+ def __getitem__(self, key: str) -> Any:
+ return self.additional_properties[key]
+
+ def __setitem__(self, key: str, value: Any) -> None:
+ self.additional_properties[key] = value
+
+ def __delitem__(self, key: str) -> None:
+ del self.additional_properties[key]
+
+ def __contains__(self, key: str) -> bool:
+ return key in self.additional_properties