2342 lines
69 KiB
Python
2342 lines
69 KiB
Python
from typing import Any, Dict, List, Type, TypeVar, Union
|
|
|
|
import attr
|
|
|
|
from ..models.center_of_mass import CenterOfMass
|
|
from ..models.curve_get_control_points import CurveGetControlPoints
|
|
from ..models.curve_get_end_points import CurveGetEndPoints
|
|
from ..models.curve_get_type import CurveGetType
|
|
from ..models.density import Density
|
|
from ..models.entity_get_all_child_uuids import EntityGetAllChildUuids
|
|
from ..models.entity_get_child_uuid import EntityGetChildUuid
|
|
from ..models.entity_get_num_children import EntityGetNumChildren
|
|
from ..models.entity_get_parent_id import EntityGetParentId
|
|
from ..models.export import Export
|
|
from ..models.get_entity_type import GetEntityType
|
|
from ..models.get_sketch_mode_plane import GetSketchModePlane
|
|
from ..models.highlight_set_entity import HighlightSetEntity
|
|
from ..models.import_files import ImportFiles
|
|
from ..models.mass import Mass
|
|
from ..models.mouse_click import MouseClick
|
|
from ..models.path_get_curve_uuids_for_vertices import PathGetCurveUuidsForVertices
|
|
from ..models.path_get_info import PathGetInfo
|
|
from ..models.path_get_vertex_uuids import PathGetVertexUuids
|
|
from ..models.plane_intersect_and_project import PlaneIntersectAndProject
|
|
from ..models.select_get import SelectGet
|
|
from ..models.select_with_point import SelectWithPoint
|
|
from ..models.solid3d_get_all_edge_faces import Solid3dGetAllEdgeFaces
|
|
from ..models.solid3d_get_all_opposite_edges import Solid3dGetAllOppositeEdges
|
|
from ..models.solid3d_get_next_adjacent_edge import Solid3dGetNextAdjacentEdge
|
|
from ..models.solid3d_get_opposite_edge import Solid3dGetOppositeEdge
|
|
from ..models.solid3d_get_prev_adjacent_edge import Solid3dGetPrevAdjacentEdge
|
|
from ..models.surface_area import SurfaceArea
|
|
from ..models.take_snapshot import TakeSnapshot
|
|
from ..models.volume import Volume
|
|
from ..types import UNSET, Unset
|
|
|
|
FO = TypeVar("FO", bound="empty")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class empty:
|
|
"""An empty response, used for any command that does not explicitly have a response defined here.""" # noqa: E501
|
|
|
|
type: str = "empty"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[FO], src_dict: Dict[str, Any]) -> FO:
|
|
d = src_dict.copy()
|
|
type = d.pop("type", UNSET)
|
|
|
|
empty = cls(
|
|
type=type,
|
|
)
|
|
|
|
empty.additional_properties = d
|
|
return empty
|
|
|
|
@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
|
|
|
|
|
|
KB = TypeVar("KB", bound="export")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class export:
|
|
"""The response from the `Export` command. When this is being performed over a websocket, this is sent as binary not JSON. The binary data can be deserialized as `bincode` into a `Vec<ExportFile>`.""" # noqa: E501
|
|
|
|
data: Union[Unset, Export] = UNSET
|
|
type: str = "export"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[KB], src_dict: Dict[str, Any]) -> KB:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Export]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Export.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
export = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
export.additional_properties = d
|
|
return export
|
|
|
|
@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
|
|
|
|
|
|
QH = TypeVar("QH", bound="select_with_point")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class select_with_point:
|
|
"""The response from the `SelectWithPoint` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, SelectWithPoint] = UNSET
|
|
type: str = "select_with_point"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[QH], src_dict: Dict[str, Any]) -> QH:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, SelectWithPoint]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = SelectWithPoint.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
select_with_point = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
select_with_point.additional_properties = d
|
|
return select_with_point
|
|
|
|
@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
|
|
|
|
|
|
EV = TypeVar("EV", bound="highlight_set_entity")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class highlight_set_entity:
|
|
"""The response from the `HighlightSetEntity` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, HighlightSetEntity] = UNSET
|
|
type: str = "highlight_set_entity"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[EV], src_dict: Dict[str, Any]) -> EV:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, HighlightSetEntity]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = HighlightSetEntity.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
highlight_set_entity = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
highlight_set_entity.additional_properties = d
|
|
return highlight_set_entity
|
|
|
|
@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
|
|
|
|
|
|
YL = TypeVar("YL", bound="entity_get_child_uuid")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class entity_get_child_uuid:
|
|
"""The response from the `EntityGetChildUuid` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, EntityGetChildUuid] = UNSET
|
|
type: str = "entity_get_child_uuid"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[YL], src_dict: Dict[str, Any]) -> YL:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, EntityGetChildUuid]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = EntityGetChildUuid.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
entity_get_child_uuid = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
entity_get_child_uuid.additional_properties = d
|
|
return entity_get_child_uuid
|
|
|
|
@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
|
|
|
|
|
|
AN = TypeVar("AN", bound="entity_get_num_children")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class entity_get_num_children:
|
|
"""The response from the `EntityGetNumChildren` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, EntityGetNumChildren] = UNSET
|
|
type: str = "entity_get_num_children"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[AN], src_dict: Dict[str, Any]) -> AN:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, EntityGetNumChildren]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = EntityGetNumChildren.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
entity_get_num_children = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
entity_get_num_children.additional_properties = d
|
|
return entity_get_num_children
|
|
|
|
@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
|
|
|
|
|
|
UV = TypeVar("UV", bound="entity_get_parent_id")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class entity_get_parent_id:
|
|
"""The response from the `EntityGetParentId` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, EntityGetParentId] = UNSET
|
|
type: str = "entity_get_parent_id"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[UV], src_dict: Dict[str, Any]) -> UV:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, EntityGetParentId]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = EntityGetParentId.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
entity_get_parent_id = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
entity_get_parent_id.additional_properties = d
|
|
return entity_get_parent_id
|
|
|
|
@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
|
|
|
|
|
|
IB = TypeVar("IB", bound="entity_get_all_child_uuids")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class entity_get_all_child_uuids:
|
|
"""The response from the `EntityGetAllChildUuids` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, EntityGetAllChildUuids] = UNSET
|
|
type: str = "entity_get_all_child_uuids"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[IB], src_dict: Dict[str, Any]) -> IB:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, EntityGetAllChildUuids]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = EntityGetAllChildUuids.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
entity_get_all_child_uuids = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
entity_get_all_child_uuids.additional_properties = d
|
|
return entity_get_all_child_uuids
|
|
|
|
@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
|
|
|
|
|
|
EU = TypeVar("EU", bound="select_get")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class select_get:
|
|
"""The response from the `SelectGet` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, SelectGet] = UNSET
|
|
type: str = "select_get"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[EU], src_dict: Dict[str, Any]) -> EU:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, SelectGet]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = SelectGet.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
select_get = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
select_get.additional_properties = d
|
|
return select_get
|
|
|
|
@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
|
|
|
|
|
|
QW = TypeVar("QW", bound="get_entity_type")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class get_entity_type:
|
|
"""The response from the `GetEntityType` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, GetEntityType] = UNSET
|
|
type: str = "get_entity_type"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[QW], src_dict: Dict[str, Any]) -> QW:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, GetEntityType]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = GetEntityType.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
get_entity_type = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
get_entity_type.additional_properties = d
|
|
return get_entity_type
|
|
|
|
@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
|
|
|
|
|
|
RN = TypeVar("RN", bound="solid3d_get_all_edge_faces")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class solid3d_get_all_edge_faces:
|
|
"""The response from the `Solid3dGetAllEdgeFaces` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Solid3dGetAllEdgeFaces] = UNSET
|
|
type: str = "solid3d_get_all_edge_faces"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[RN], src_dict: Dict[str, Any]) -> RN:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Solid3dGetAllEdgeFaces]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Solid3dGetAllEdgeFaces.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
solid3d_get_all_edge_faces = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
solid3d_get_all_edge_faces.additional_properties = d
|
|
return solid3d_get_all_edge_faces
|
|
|
|
@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
|
|
|
|
|
|
JN = TypeVar("JN", bound="solid3d_get_all_opposite_edges")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class solid3d_get_all_opposite_edges:
|
|
"""The response from the `Solid3dGetAllOppositeEdges` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Solid3dGetAllOppositeEdges] = UNSET
|
|
type: str = "solid3d_get_all_opposite_edges"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[JN], src_dict: Dict[str, Any]) -> JN:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Solid3dGetAllOppositeEdges]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Solid3dGetAllOppositeEdges.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
solid3d_get_all_opposite_edges = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
solid3d_get_all_opposite_edges.additional_properties = d
|
|
return solid3d_get_all_opposite_edges
|
|
|
|
@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
|
|
|
|
|
|
BD = TypeVar("BD", bound="solid3d_get_opposite_edge")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class solid3d_get_opposite_edge:
|
|
"""The response from the `Solid3dGetOppositeEdge` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Solid3dGetOppositeEdge] = UNSET
|
|
type: str = "solid3d_get_opposite_edge"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[BD], src_dict: Dict[str, Any]) -> BD:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Solid3dGetOppositeEdge]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Solid3dGetOppositeEdge.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
solid3d_get_opposite_edge = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
solid3d_get_opposite_edge.additional_properties = d
|
|
return solid3d_get_opposite_edge
|
|
|
|
@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
|
|
|
|
|
|
XW = TypeVar("XW", bound="solid3d_get_prev_adjacent_edge")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class solid3d_get_prev_adjacent_edge:
|
|
"""The response from the `Solid3dGetPrevAdjacentEdge` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Solid3dGetPrevAdjacentEdge] = UNSET
|
|
type: str = "solid3d_get_prev_adjacent_edge"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[XW], src_dict: Dict[str, Any]) -> XW:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Solid3dGetPrevAdjacentEdge]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Solid3dGetPrevAdjacentEdge.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
solid3d_get_prev_adjacent_edge = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
solid3d_get_prev_adjacent_edge.additional_properties = d
|
|
return solid3d_get_prev_adjacent_edge
|
|
|
|
@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
|
|
|
|
|
|
LP = TypeVar("LP", bound="solid3d_get_next_adjacent_edge")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class solid3d_get_next_adjacent_edge:
|
|
"""The response from the `Solid3dGetNextAdjacentEdge` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Solid3dGetNextAdjacentEdge] = UNSET
|
|
type: str = "solid3d_get_next_adjacent_edge"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[LP], src_dict: Dict[str, Any]) -> LP:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Solid3dGetNextAdjacentEdge]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Solid3dGetNextAdjacentEdge.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
solid3d_get_next_adjacent_edge = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
solid3d_get_next_adjacent_edge.additional_properties = d
|
|
return solid3d_get_next_adjacent_edge
|
|
|
|
@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
|
|
|
|
|
|
XN = TypeVar("XN", bound="mouse_click")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class mouse_click:
|
|
"""The response from the `MouseClick` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, MouseClick] = UNSET
|
|
type: str = "mouse_click"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[XN], src_dict: Dict[str, Any]) -> XN:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, MouseClick]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = MouseClick.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
mouse_click = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
mouse_click.additional_properties = d
|
|
return mouse_click
|
|
|
|
@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
|
|
|
|
|
|
PL = TypeVar("PL", bound="curve_get_type")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class curve_get_type:
|
|
"""The response from the `CurveGetType` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, CurveGetType] = UNSET
|
|
type: str = "curve_get_type"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[PL], src_dict: Dict[str, Any]) -> PL:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, CurveGetType]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = CurveGetType.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
curve_get_type = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
curve_get_type.additional_properties = d
|
|
return curve_get_type
|
|
|
|
@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
|
|
|
|
|
|
XS = TypeVar("XS", bound="curve_get_control_points")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class curve_get_control_points:
|
|
"""The response from the `CurveGetControlPoints` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, CurveGetControlPoints] = UNSET
|
|
type: str = "curve_get_control_points"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[XS], src_dict: Dict[str, Any]) -> XS:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, CurveGetControlPoints]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = CurveGetControlPoints.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
curve_get_control_points = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
curve_get_control_points.additional_properties = d
|
|
return curve_get_control_points
|
|
|
|
@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
|
|
|
|
|
|
YB = TypeVar("YB", bound="take_snapshot")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class take_snapshot:
|
|
"""The response from the `Take Snapshot` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, TakeSnapshot] = UNSET
|
|
type: str = "take_snapshot"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[YB], src_dict: Dict[str, Any]) -> YB:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, TakeSnapshot]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = TakeSnapshot.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
take_snapshot = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
take_snapshot.additional_properties = d
|
|
return take_snapshot
|
|
|
|
@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
|
|
|
|
|
|
YX = TypeVar("YX", bound="path_get_info")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class path_get_info:
|
|
"""The response from the `Path Get Info` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, PathGetInfo] = UNSET
|
|
type: str = "path_get_info"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[YX], src_dict: Dict[str, Any]) -> YX:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, PathGetInfo]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = PathGetInfo.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
path_get_info = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
path_get_info.additional_properties = d
|
|
return path_get_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
|
|
|
|
|
|
LM = TypeVar("LM", bound="path_get_curve_uuids_for_vertices")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class path_get_curve_uuids_for_vertices:
|
|
"""The response from the `Path Get Curve UUIDs for Vertices` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, PathGetCurveUuidsForVertices] = UNSET
|
|
type: str = "path_get_curve_uuids_for_vertices"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[LM], src_dict: Dict[str, Any]) -> LM:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, PathGetCurveUuidsForVertices]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = PathGetCurveUuidsForVertices.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
path_get_curve_uuids_for_vertices = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
path_get_curve_uuids_for_vertices.additional_properties = d
|
|
return path_get_curve_uuids_for_vertices
|
|
|
|
@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
|
|
|
|
|
|
DM = TypeVar("DM", bound="path_get_vertex_uuids")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class path_get_vertex_uuids:
|
|
"""The response from the `Path Get Vertex UUIDs` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, PathGetVertexUuids] = UNSET
|
|
type: str = "path_get_vertex_uuids"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[DM], src_dict: Dict[str, Any]) -> DM:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, PathGetVertexUuids]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = PathGetVertexUuids.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
path_get_vertex_uuids = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
path_get_vertex_uuids.additional_properties = d
|
|
return path_get_vertex_uuids
|
|
|
|
@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
|
|
|
|
|
|
HZ = TypeVar("HZ", bound="plane_intersect_and_project")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class plane_intersect_and_project:
|
|
"""The response from the `PlaneIntersectAndProject` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, PlaneIntersectAndProject] = UNSET
|
|
type: str = "plane_intersect_and_project"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[HZ], src_dict: Dict[str, Any]) -> HZ:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, PlaneIntersectAndProject]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = PlaneIntersectAndProject.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
plane_intersect_and_project = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
plane_intersect_and_project.additional_properties = d
|
|
return plane_intersect_and_project
|
|
|
|
@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
|
|
|
|
|
|
CP = TypeVar("CP", bound="curve_get_end_points")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class curve_get_end_points:
|
|
"""The response from the `CurveGetEndPoints` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, CurveGetEndPoints] = UNSET
|
|
type: str = "curve_get_end_points"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[CP], src_dict: Dict[str, Any]) -> CP:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, CurveGetEndPoints]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = CurveGetEndPoints.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
curve_get_end_points = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
curve_get_end_points.additional_properties = d
|
|
return curve_get_end_points
|
|
|
|
@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
|
|
|
|
|
|
IP = TypeVar("IP", bound="import_files")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class import_files:
|
|
"""The response from the `ImportFiles` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, ImportFiles] = UNSET
|
|
type: str = "import_files"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[IP], src_dict: Dict[str, Any]) -> IP:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, ImportFiles]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = ImportFiles.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
import_files = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
import_files.additional_properties = d
|
|
return import_files
|
|
|
|
@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
|
|
|
|
|
|
XV = TypeVar("XV", bound="mass")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class mass:
|
|
"""The response from the `Mass` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Mass] = UNSET
|
|
type: str = "mass"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[XV], src_dict: Dict[str, Any]) -> XV:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Mass]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Mass.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
mass = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
mass.additional_properties = d
|
|
return mass
|
|
|
|
@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
|
|
|
|
|
|
TW = TypeVar("TW", bound="volume")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class volume:
|
|
"""The response from the `Volume` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Volume] = UNSET
|
|
type: str = "volume"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[TW], src_dict: Dict[str, Any]) -> TW:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Volume]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Volume.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
volume = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
volume.additional_properties = d
|
|
return volume
|
|
|
|
@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
|
|
|
|
|
|
CH = TypeVar("CH", bound="density")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class density:
|
|
"""The response from the `Density` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, Density] = UNSET
|
|
type: str = "density"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[CH], src_dict: Dict[str, Any]) -> CH:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, Density]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = Density.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
density = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
density.additional_properties = d
|
|
return density
|
|
|
|
@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
|
|
|
|
|
|
MW = TypeVar("MW", bound="surface_area")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class surface_area:
|
|
"""The response from the `SurfaceArea` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, SurfaceArea] = UNSET
|
|
type: str = "surface_area"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[MW], src_dict: Dict[str, Any]) -> MW:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, SurfaceArea]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = SurfaceArea.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
surface_area = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
surface_area.additional_properties = d
|
|
return surface_area
|
|
|
|
@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
|
|
|
|
|
|
VN = TypeVar("VN", bound="center_of_mass")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class center_of_mass:
|
|
"""The response from the `CenterOfMass` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, CenterOfMass] = UNSET
|
|
type: str = "center_of_mass"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[VN], src_dict: Dict[str, Any]) -> VN:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, CenterOfMass]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = CenterOfMass.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
center_of_mass = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
center_of_mass.additional_properties = d
|
|
return center_of_mass
|
|
|
|
@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
|
|
|
|
|
|
WE = TypeVar("WE", bound="get_sketch_mode_plane")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class get_sketch_mode_plane:
|
|
"""The response from the `GetSketchModePlane` command.""" # noqa: E501
|
|
|
|
data: Union[Unset, GetSketchModePlane] = UNSET
|
|
type: str = "get_sketch_mode_plane"
|
|
|
|
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if not isinstance(self.data, Unset):
|
|
data = self.data
|
|
type = self.type
|
|
|
|
field_dict: Dict[str, Any] = {}
|
|
field_dict.update(self.additional_properties)
|
|
field_dict.update({})
|
|
if data is not UNSET:
|
|
field_dict["data"] = data.to_dict()
|
|
field_dict["type"] = type
|
|
|
|
return field_dict
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[WE], src_dict: Dict[str, Any]) -> WE:
|
|
d = src_dict.copy()
|
|
_data = d.pop("data", UNSET)
|
|
data: Union[Unset, GetSketchModePlane]
|
|
if isinstance(_data, Unset):
|
|
data = UNSET
|
|
if _data is None:
|
|
data = UNSET
|
|
else:
|
|
data = GetSketchModePlane.from_dict(_data)
|
|
|
|
type = d.pop("type", UNSET)
|
|
|
|
get_sketch_mode_plane = cls(
|
|
data=data,
|
|
type=type,
|
|
)
|
|
|
|
get_sketch_mode_plane.additional_properties = d
|
|
return get_sketch_mode_plane
|
|
|
|
@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
|
|
|
|
|
|
GY = TypeVar("GY", bound="OkModelingCmdResponse")
|
|
|
|
|
|
@attr.s(auto_attribs=True)
|
|
class OkModelingCmdResponse:
|
|
|
|
"""A successful response from a modeling command. This can be one of several types of responses, depending on the command."""
|
|
|
|
type: Union[
|
|
empty,
|
|
export,
|
|
select_with_point,
|
|
highlight_set_entity,
|
|
entity_get_child_uuid,
|
|
entity_get_num_children,
|
|
entity_get_parent_id,
|
|
entity_get_all_child_uuids,
|
|
select_get,
|
|
get_entity_type,
|
|
solid3d_get_all_edge_faces,
|
|
solid3d_get_all_opposite_edges,
|
|
solid3d_get_opposite_edge,
|
|
solid3d_get_prev_adjacent_edge,
|
|
solid3d_get_next_adjacent_edge,
|
|
mouse_click,
|
|
curve_get_type,
|
|
curve_get_control_points,
|
|
take_snapshot,
|
|
path_get_info,
|
|
path_get_curve_uuids_for_vertices,
|
|
path_get_vertex_uuids,
|
|
plane_intersect_and_project,
|
|
curve_get_end_points,
|
|
import_files,
|
|
mass,
|
|
volume,
|
|
density,
|
|
surface_area,
|
|
center_of_mass,
|
|
get_sketch_mode_plane,
|
|
]
|
|
|
|
def __init__(
|
|
self,
|
|
type: Union[
|
|
empty,
|
|
export,
|
|
select_with_point,
|
|
highlight_set_entity,
|
|
entity_get_child_uuid,
|
|
entity_get_num_children,
|
|
entity_get_parent_id,
|
|
entity_get_all_child_uuids,
|
|
select_get,
|
|
get_entity_type,
|
|
solid3d_get_all_edge_faces,
|
|
solid3d_get_all_opposite_edges,
|
|
solid3d_get_opposite_edge,
|
|
solid3d_get_prev_adjacent_edge,
|
|
solid3d_get_next_adjacent_edge,
|
|
mouse_click,
|
|
curve_get_type,
|
|
curve_get_control_points,
|
|
take_snapshot,
|
|
path_get_info,
|
|
path_get_curve_uuids_for_vertices,
|
|
path_get_vertex_uuids,
|
|
plane_intersect_and_project,
|
|
curve_get_end_points,
|
|
import_files,
|
|
mass,
|
|
volume,
|
|
density,
|
|
surface_area,
|
|
center_of_mass,
|
|
get_sketch_mode_plane,
|
|
],
|
|
):
|
|
self.type = type
|
|
|
|
def to_dict(self) -> Dict[str, Any]:
|
|
if isinstance(self.type, empty):
|
|
YZ: empty = self.type
|
|
return YZ.to_dict()
|
|
elif isinstance(self.type, export):
|
|
SV: export = self.type
|
|
return SV.to_dict()
|
|
elif isinstance(self.type, select_with_point):
|
|
ZF: select_with_point = self.type
|
|
return ZF.to_dict()
|
|
elif isinstance(self.type, highlight_set_entity):
|
|
RA: highlight_set_entity = self.type
|
|
return RA.to_dict()
|
|
elif isinstance(self.type, entity_get_child_uuid):
|
|
KP: entity_get_child_uuid = self.type
|
|
return KP.to_dict()
|
|
elif isinstance(self.type, entity_get_num_children):
|
|
HM: entity_get_num_children = self.type
|
|
return HM.to_dict()
|
|
elif isinstance(self.type, entity_get_parent_id):
|
|
NT: entity_get_parent_id = self.type
|
|
return NT.to_dict()
|
|
elif isinstance(self.type, entity_get_all_child_uuids):
|
|
IH: entity_get_all_child_uuids = self.type
|
|
return IH.to_dict()
|
|
elif isinstance(self.type, select_get):
|
|
WK: select_get = self.type
|
|
return WK.to_dict()
|
|
elif isinstance(self.type, get_entity_type):
|
|
CA: get_entity_type = self.type
|
|
return CA.to_dict()
|
|
elif isinstance(self.type, solid3d_get_all_edge_faces):
|
|
AF: solid3d_get_all_edge_faces = self.type
|
|
return AF.to_dict()
|
|
elif isinstance(self.type, solid3d_get_all_opposite_edges):
|
|
IY: solid3d_get_all_opposite_edges = self.type
|
|
return IY.to_dict()
|
|
elif isinstance(self.type, solid3d_get_opposite_edge):
|
|
QB: solid3d_get_opposite_edge = self.type
|
|
return QB.to_dict()
|
|
elif isinstance(self.type, solid3d_get_prev_adjacent_edge):
|
|
QN: solid3d_get_prev_adjacent_edge = self.type
|
|
return QN.to_dict()
|
|
elif isinstance(self.type, solid3d_get_next_adjacent_edge):
|
|
VL: solid3d_get_next_adjacent_edge = self.type
|
|
return VL.to_dict()
|
|
elif isinstance(self.type, mouse_click):
|
|
IW: mouse_click = self.type
|
|
return IW.to_dict()
|
|
elif isinstance(self.type, curve_get_type):
|
|
LW: curve_get_type = self.type
|
|
return LW.to_dict()
|
|
elif isinstance(self.type, curve_get_control_points):
|
|
ID: curve_get_control_points = self.type
|
|
return ID.to_dict()
|
|
elif isinstance(self.type, take_snapshot):
|
|
NI: take_snapshot = self.type
|
|
return NI.to_dict()
|
|
elif isinstance(self.type, path_get_info):
|
|
BY: path_get_info = self.type
|
|
return BY.to_dict()
|
|
elif isinstance(self.type, path_get_curve_uuids_for_vertices):
|
|
IC: path_get_curve_uuids_for_vertices = self.type
|
|
return IC.to_dict()
|
|
elif isinstance(self.type, path_get_vertex_uuids):
|
|
SH: path_get_vertex_uuids = self.type
|
|
return SH.to_dict()
|
|
elif isinstance(self.type, plane_intersect_and_project):
|
|
RV: plane_intersect_and_project = self.type
|
|
return RV.to_dict()
|
|
elif isinstance(self.type, curve_get_end_points):
|
|
TI: curve_get_end_points = self.type
|
|
return TI.to_dict()
|
|
elif isinstance(self.type, import_files):
|
|
KO: import_files = self.type
|
|
return KO.to_dict()
|
|
elif isinstance(self.type, mass):
|
|
AL: mass = self.type
|
|
return AL.to_dict()
|
|
elif isinstance(self.type, volume):
|
|
ZH: volume = self.type
|
|
return ZH.to_dict()
|
|
elif isinstance(self.type, density):
|
|
KD: density = self.type
|
|
return KD.to_dict()
|
|
elif isinstance(self.type, surface_area):
|
|
YA: surface_area = self.type
|
|
return YA.to_dict()
|
|
elif isinstance(self.type, center_of_mass):
|
|
WD: center_of_mass = self.type
|
|
return WD.to_dict()
|
|
elif isinstance(self.type, get_sketch_mode_plane):
|
|
RJ: get_sketch_mode_plane = self.type
|
|
return RJ.to_dict()
|
|
|
|
raise Exception("Unknown type")
|
|
|
|
@classmethod
|
|
def from_dict(cls: Type[GY], d: Dict[str, Any]) -> GY:
|
|
if d.get("type") == "empty":
|
|
GZ: empty = empty()
|
|
GZ.from_dict(d)
|
|
return cls(type=GZ)
|
|
elif d.get("type") == "export":
|
|
XB: export = export()
|
|
XB.from_dict(d)
|
|
return cls(type=XB)
|
|
elif d.get("type") == "select_with_point":
|
|
XM: select_with_point = select_with_point()
|
|
XM.from_dict(d)
|
|
return cls(type=XM)
|
|
elif d.get("type") == "highlight_set_entity":
|
|
TQ: highlight_set_entity = highlight_set_entity()
|
|
TQ.from_dict(d)
|
|
return cls(type=TQ)
|
|
elif d.get("type") == "entity_get_child_uuid":
|
|
SU: entity_get_child_uuid = entity_get_child_uuid()
|
|
SU.from_dict(d)
|
|
return cls(type=SU)
|
|
elif d.get("type") == "entity_get_num_children":
|
|
QD: entity_get_num_children = entity_get_num_children()
|
|
QD.from_dict(d)
|
|
return cls(type=QD)
|
|
elif d.get("type") == "entity_get_parent_id":
|
|
XC: entity_get_parent_id = entity_get_parent_id()
|
|
XC.from_dict(d)
|
|
return cls(type=XC)
|
|
elif d.get("type") == "entity_get_all_child_uuids":
|
|
IX: entity_get_all_child_uuids = entity_get_all_child_uuids()
|
|
IX.from_dict(d)
|
|
return cls(type=IX)
|
|
elif d.get("type") == "select_get":
|
|
YS: select_get = select_get()
|
|
YS.from_dict(d)
|
|
return cls(type=YS)
|
|
elif d.get("type") == "get_entity_type":
|
|
TT: get_entity_type = get_entity_type()
|
|
TT.from_dict(d)
|
|
return cls(type=TT)
|
|
elif d.get("type") == "solid3d_get_all_edge_faces":
|
|
CK: solid3d_get_all_edge_faces = solid3d_get_all_edge_faces()
|
|
CK.from_dict(d)
|
|
return cls(type=CK)
|
|
elif d.get("type") == "solid3d_get_all_opposite_edges":
|
|
BO: solid3d_get_all_opposite_edges = solid3d_get_all_opposite_edges()
|
|
BO.from_dict(d)
|
|
return cls(type=BO)
|
|
elif d.get("type") == "solid3d_get_opposite_edge":
|
|
VB: solid3d_get_opposite_edge = solid3d_get_opposite_edge()
|
|
VB.from_dict(d)
|
|
return cls(type=VB)
|
|
elif d.get("type") == "solid3d_get_prev_adjacent_edge":
|
|
RR: solid3d_get_prev_adjacent_edge = solid3d_get_prev_adjacent_edge()
|
|
RR.from_dict(d)
|
|
return cls(type=RR)
|
|
elif d.get("type") == "solid3d_get_next_adjacent_edge":
|
|
JS: solid3d_get_next_adjacent_edge = solid3d_get_next_adjacent_edge()
|
|
JS.from_dict(d)
|
|
return cls(type=JS)
|
|
elif d.get("type") == "mouse_click":
|
|
JU: mouse_click = mouse_click()
|
|
JU.from_dict(d)
|
|
return cls(type=JU)
|
|
elif d.get("type") == "curve_get_type":
|
|
MF: curve_get_type = curve_get_type()
|
|
MF.from_dict(d)
|
|
return cls(type=MF)
|
|
elif d.get("type") == "curve_get_control_points":
|
|
ER: curve_get_control_points = curve_get_control_points()
|
|
ER.from_dict(d)
|
|
return cls(type=ER)
|
|
elif d.get("type") == "take_snapshot":
|
|
GV: take_snapshot = take_snapshot()
|
|
GV.from_dict(d)
|
|
return cls(type=GV)
|
|
elif d.get("type") == "path_get_info":
|
|
SR: path_get_info = path_get_info()
|
|
SR.from_dict(d)
|
|
return cls(type=SR)
|
|
elif d.get("type") == "path_get_curve_uuids_for_vertices":
|
|
CU: path_get_curve_uuids_for_vertices = path_get_curve_uuids_for_vertices()
|
|
CU.from_dict(d)
|
|
return cls(type=CU)
|
|
elif d.get("type") == "path_get_vertex_uuids":
|
|
OZ: path_get_vertex_uuids = path_get_vertex_uuids()
|
|
OZ.from_dict(d)
|
|
return cls(type=OZ)
|
|
elif d.get("type") == "plane_intersect_and_project":
|
|
HS: plane_intersect_and_project = plane_intersect_and_project()
|
|
HS.from_dict(d)
|
|
return cls(type=HS)
|
|
elif d.get("type") == "curve_get_end_points":
|
|
JB: curve_get_end_points = curve_get_end_points()
|
|
JB.from_dict(d)
|
|
return cls(type=JB)
|
|
elif d.get("type") == "import_files":
|
|
RP: import_files = import_files()
|
|
RP.from_dict(d)
|
|
return cls(type=RP)
|
|
elif d.get("type") == "mass":
|
|
PF: mass = mass()
|
|
PF.from_dict(d)
|
|
return cls(type=PF)
|
|
elif d.get("type") == "volume":
|
|
KV: volume = volume()
|
|
KV.from_dict(d)
|
|
return cls(type=KV)
|
|
elif d.get("type") == "density":
|
|
IN: density = density()
|
|
IN.from_dict(d)
|
|
return cls(type=IN)
|
|
elif d.get("type") == "surface_area":
|
|
QR: surface_area = surface_area()
|
|
QR.from_dict(d)
|
|
return cls(type=QR)
|
|
elif d.get("type") == "center_of_mass":
|
|
PG: center_of_mass = center_of_mass()
|
|
PG.from_dict(d)
|
|
return cls(type=PG)
|
|
elif d.get("type") == "get_sketch_mode_plane":
|
|
QS: get_sketch_mode_plane = get_sketch_mode_plane()
|
|
QS.from_dict(d)
|
|
return cls(type=QS)
|
|
|
|
raise Exception("Unknown type")
|