DipsScripting 9.1.0__py3-none-any.whl

dips/ValidatableResult_ProtoReference_PitchGridToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_PitchGridToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .PitchGridToolEntityInfoRef import PitchGridToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_PitchGridToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_PitchGridToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_PitchGridToolEntityInfo
+
+
+    def __init__(self, result: Optional[PitchGridToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_PitchGridToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> PitchGridToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return PitchGridToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: PitchGridToolEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_PlaneEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_PlaneEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .PlaneEntityInfoRef import PlaneEntityInfoRef
+
+class ValidatableResult_ProtoReference_PlaneEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_PlaneEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_PlaneEntityInfo
+
+
+    def __init__(self, result: Optional[PlaneEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_PlaneEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> PlaneEntityInfoRef:
+        """Get the Result field as a reference."""
+        return PlaneEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: PlaneEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_PlaneIntersectionCalculatorToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_PlaneIntersectionCalculatorToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .PlaneIntersectionCalculatorToolEntityInfoRef import PlaneIntersectionCalculatorToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_PlaneIntersectionCalculatorToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_PlaneIntersectionCalculatorToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_PlaneIntersectionCalculatorToolEntityInfo
+
+
+    def __init__(self, result: Optional[PlaneIntersectionCalculatorToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_PlaneIntersectionCalculatorToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> PlaneIntersectionCalculatorToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return PlaneIntersectionCalculatorToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: PlaneIntersectionCalculatorToolEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_PolygonToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_PolygonToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .PolygonToolEntityInfoRef import PolygonToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_PolygonToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_PolygonToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_PolygonToolEntityInfo
+
+
+    def __init__(self, result: Optional[PolygonToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_PolygonToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> PolygonToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return PolygonToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: PolygonToolEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_PolylineToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_PolylineToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .PolylineToolEntityInfoRef import PolylineToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_PolylineToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_PolylineToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_PolylineToolEntityInfo
+
+
+    def __init__(self, result: Optional[PolylineToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_PolylineToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> PolylineToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return PolylineToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: PolylineToolEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_RectangleToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_RectangleToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .RectangleToolEntityInfoRef import RectangleToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_RectangleToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_RectangleToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_RectangleToolEntityInfo
+
+
+    def __init__(self, result: Optional[RectangleToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_RectangleToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> RectangleToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return RectangleToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: RectangleToolEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/ValidatableResult_ProtoReference_SetEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_SetEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .SetEntityInfoRef import SetEntityInfoRef
+
+class ValidatableResult_ProtoReference_SetEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_SetEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_SetEntityInfo
+
+
+    def __init__(self, result: Optional[SetEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_SetEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        # Store channel for reference types
+        self.__channelToConnectOn = channel_to_connect_on
+
+        if result is not None:
+            self.result = result
+
+
+    # Properties
+
+    @property
+    def errors(self) -> List[ValidationErrorVal]:
+        """Get the Errors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Errors, ValidationErrorVal)
+    
+    @errors.setter
+    def errors(self, value: List[ValidationErrorVal]) -> None:
+        """Set the Errors field to a list of wrappers."""
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list or tuple, got {type(value).__name__}")
+        # Clear the repeated field using slice assignment
+        self._proto_message.Errors[:] = []
+        for item in value:
+            self._proto_message.Errors.append(item.to_proto())
+
+
+    @property
+    def result(self) -> SetEntityInfoRef:
+        """Get the Result field as a reference."""
+        return SetEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: SetEntityInfoRef) -> None:
+        """Set the Result field to a reference."""
+        self._proto_message.Result.CopyFrom(value.get_model_ref())
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"