Open-source, secure environment with real-world tools for enterprise-grade agents.
Python agentaiai-agentai-agentscode-interpretercopilotdevelopmentdevtoolsgptgpt-4javascriptllmnextjsopenaipythonreactsoftwaretypescript
Add missing files
Jakub Novak4b5d17e8a404
diff --git a/.gitignore b/.gitignoreindex 74d83b006..f88780942 100644--- a/.gitignore+++ b/.gitignore@@ -292,3 +292,4 @@ cython_debug/# SDK reference artifactssdk_ref/sdkRefRoutes.json+spec/openapi_generated.yml\ No newline at end of filediff --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.pynew file mode 100644index 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,+ )+ ).parseddiff --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.pynew file mode 100644index 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.pynew file mode 100644index 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,+ )+ ).parseddiff --git a/packages/python-sdk/e2b/api/client/models/node.py b/packages/python-sdk/e2b/api/client/models/node.pynew file mode 100644index 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_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/node_detail.py b/packages/python-sdk/e2b/api/client/models/node_detail.pynew file mode 100644index 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_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/node_status.py b/packages/python-sdk/e2b/api/client/models/node_status.pynew file mode 100644index 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.pynew file mode 100644index 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_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/resumed_sandbox.py b/packages/python-sdk/e2b/api/client/models/resumed_sandbox.pynew file mode 100644index 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_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/team_user.py b/packages/python-sdk/e2b/api/client/models/team_user.pynew file mode 100644index 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_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/template_update_request.py b/packages/python-sdk/e2b/api/client/models/template_update_request.pynew file mode 100644index 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