loopix-sdk 2.30.0__py3-none-any.whl

loopix/api/client/models/sandbox_network_update_config.py

@@ -0,0 +1,114 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sandbox_network_update_config_rules import (
+        SandboxNetworkUpdateConfigRules,
+    )
+
+
+T = TypeVar("T", bound="SandboxNetworkUpdateConfig")
+
+
+@_attrs_define
+class SandboxNetworkUpdateConfig:
+    """Network configuration update for a running sandbox. Replaces the current egress rules with the provided
+    configuration. Omitting a field clears it.
+
+        Attributes:
+            allow_out (Union[Unset, list[str]]): List of allowed destinations for egress traffic. Each entry can be a CIDR
+                block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com",
+                "*.example.com"). Allowed entries always take precedence over denied entries.
+            allow_internet_access (Union[Unset, bool]): Allow sandbox to access the internet. When set to false, it behaves
+                the same as specifying denyOut to 0.0.0.0/0 in the network config.
+            deny_out (Union[Unset, list[str]]): List of denied CIDR blocks or IP addresses for egress traffic. Domain names
+                are not supported for deny rules.
+            rules (Union[Unset, SandboxNetworkUpdateConfigRules]): Per-domain transform rules. Replaces all existing rules
+                when provided.
+    """
+
+    allow_out: Union[Unset, list[str]] = UNSET
+    allow_internet_access: Union[Unset, bool] = UNSET
+    deny_out: Union[Unset, list[str]] = UNSET
+    rules: Union[Unset, "SandboxNetworkUpdateConfigRules"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        allow_out: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.allow_out, Unset):
+            allow_out = self.allow_out
+
+        allow_internet_access = self.allow_internet_access
+
+        deny_out: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.deny_out, Unset):
+            deny_out = self.deny_out
+
+        rules: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.rules, Unset):
+            rules = self.rules.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if allow_out is not UNSET:
+            field_dict["allowOut"] = allow_out
+        if allow_internet_access is not UNSET:
+            field_dict["allow_internet_access"] = allow_internet_access
+        if deny_out is not UNSET:
+            field_dict["denyOut"] = deny_out
+        if rules is not UNSET:
+            field_dict["rules"] = rules
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_network_update_config_rules import (
+            SandboxNetworkUpdateConfigRules,
+        )
+
+        d = dict(src_dict)
+        allow_out = cast(list[str], d.pop("allowOut", UNSET))
+
+        allow_internet_access = d.pop("allow_internet_access", UNSET)
+
+        deny_out = cast(list[str], d.pop("denyOut", UNSET))
+
+        _rules = d.pop("rules", UNSET)
+        rules: Union[Unset, SandboxNetworkUpdateConfigRules]
+        if isinstance(_rules, Unset):
+            rules = UNSET
+        else:
+            rules = SandboxNetworkUpdateConfigRules.from_dict(_rules)
+
+        sandbox_network_update_config = cls(
+            allow_out=allow_out,
+            allow_internet_access=allow_internet_access,
+            deny_out=deny_out,
+            rules=rules,
+        )
+
+        sandbox_network_update_config.additional_properties = d
+        return sandbox_network_update_config
+
+    @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

loopix/api/client/models/sandbox_network_update_config_rules.py

@@ -0,0 +1,71 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.sandbox_network_rule import SandboxNetworkRule
+
+
+T = TypeVar("T", bound="SandboxNetworkUpdateConfigRules")
+
+
+@_attrs_define
+class SandboxNetworkUpdateConfigRules:
+    """Per-domain transform rules. Replaces all existing rules when provided."""
+
+    additional_properties: dict[str, list["SandboxNetworkRule"]] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = []
+            for additional_property_item_data in prop:
+                additional_property_item = additional_property_item_data.to_dict()
+                field_dict[prop_name].append(additional_property_item)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sandbox_network_rule import SandboxNetworkRule
+
+        d = dict(src_dict)
+        sandbox_network_update_config_rules = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = []
+            _additional_property = prop_dict
+            for additional_property_item_data in _additional_property:
+                additional_property_item = SandboxNetworkRule.from_dict(
+                    additional_property_item_data
+                )
+
+                additional_property.append(additional_property_item)
+
+            additional_properties[prop_name] = additional_property
+
+        sandbox_network_update_config_rules.additional_properties = (
+            additional_properties
+        )
+        return sandbox_network_update_config_rules
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list["SandboxNetworkRule"]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list["SandboxNetworkRule"]) -> 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

loopix/api/client/models/sandbox_on_timeout.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SandboxOnTimeout(str, Enum):
+    KILL = "kill"
+    PAUSE = "pause"
+
+    def __str__(self) -> str:
+        return str(self.value)

loopix/api/client/models/sandbox_pause_request.py

@@ -0,0 +1,62 @@
+from collections.abc import Mapping
+from typing import Any, 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="SandboxPauseRequest")
+
+
+@_attrs_define
+class SandboxPauseRequest:
+    """
+    Attributes:
+        memory (Union[Unset, bool]): Whether to capture a full memory snapshot. When false, only the filesystem is
+            persisted and resuming the sandbox cold-boots (reboots) it from disk, losing in-memory state, running processes,
+            and open connections. Resume it with an explicit request (connect or resume); auto-resume, which can be
+            triggered by arbitrary traffic, refuses such a sandbox. Defaults to true. Default: True.
+    """
+
+    memory: Union[Unset, bool] = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        memory = self.memory
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if memory is not UNSET:
+            field_dict["memory"] = memory
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        memory = d.pop("memory", UNSET)
+
+        sandbox_pause_request = cls(
+            memory=memory,
+        )
+
+        sandbox_pause_request.additional_properties = d
+        return sandbox_pause_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

loopix/api/client/models/sandbox_state.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class SandboxState(str, Enum):
+    PAUSED = "paused"
+    RUNNING = "running"
+
+    def __str__(self) -> str:
+        return str(self.value)

loopix/api/client/models/sandbox_volume_mount.py

@@ -0,0 +1,67 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SandboxVolumeMount")
+
+
+@_attrs_define
+class SandboxVolumeMount:
+    """
+    Attributes:
+        name (str): Name of the volume
+        path (str): Path of the volume
+    """
+
+    name: str
+    path: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        path = self.path
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "path": path,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        path = d.pop("path")
+
+        sandbox_volume_mount = cls(
+            name=name,
+            path=path,
+        )
+
+        sandbox_volume_mount.additional_properties = d
+        return sandbox_volume_mount
+
+    @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

loopix/api/client/models/sandboxes_with_metrics.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SandboxesWithMetrics")
+
+
+@_attrs_define
+class SandboxesWithMetrics:
+    """
+    Attributes:
+        sandboxes (Any):
+    """
+
+    sandboxes: Any
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sandboxes = self.sandboxes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "sandboxes": sandboxes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sandboxes = d.pop("sandboxes")
+
+        sandboxes_with_metrics = cls(
+            sandboxes=sandboxes,
+        )
+
+        sandboxes_with_metrics.additional_properties = d
+        return sandboxes_with_metrics
+
+    @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

loopix/api/client/models/snapshot_info.py

@@ -0,0 +1,70 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SnapshotInfo")
+
+
+@_attrs_define
+class SnapshotInfo:
+    """
+    Attributes:
+        names (list[str]): Full names of the snapshot template including team namespace and tag (e.g. team-slug/my-
+            snapshot:v2)
+        snapshot_id (str): Identifier of the snapshot template including the tag. Uses namespace/alias when a name was
+            provided (e.g. team-slug/my-snapshot:default), otherwise falls back to the raw template ID (e.g.
+            abc123:default).
+    """
+
+    names: list[str]
+    snapshot_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        names = self.names
+
+        snapshot_id = self.snapshot_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "names": names,
+                "snapshotID": snapshot_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        names = cast(list[str], d.pop("names"))
+
+        snapshot_id = d.pop("snapshotID")
+
+        snapshot_info = cls(
+            names=names,
+            snapshot_id=snapshot_id,
+        )
+
+        snapshot_info.additional_properties = d
+        return snapshot_info
+
+    @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

loopix/api/client/models/team.py

@@ -0,0 +1,83 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Team")
+
+
+@_attrs_define
+class Team:
+    """
+    Attributes:
+        api_key (str): API key for the team
+        is_default (bool): Whether the team is the default team
+        name (str): Name of the team
+        team_id (str): Identifier of the team
+    """
+
+    api_key: str
+    is_default: bool
+    name: str
+    team_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        api_key = self.api_key
+
+        is_default = self.is_default
+
+        name = self.name
+
+        team_id = self.team_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "apiKey": api_key,
+                "isDefault": is_default,
+                "name": name,
+                "teamID": team_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        api_key = d.pop("apiKey")
+
+        is_default = d.pop("isDefault")
+
+        name = d.pop("name")
+
+        team_id = d.pop("teamID")
+
+        team = cls(
+            api_key=api_key,
+            is_default=is_default,
+            name=name,
+            team_id=team_id,
+        )
+
+        team.additional_properties = d
+        return team
+
+    @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