DipsScripting 9.1.0__py3-none-any.whl

dips/ValidatableResult_ProtoReference_ConeToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_ConeToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .ConeToolEntityInfoRef import ConeToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_ConeToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_ConeToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_ConeToolEntityInfo
+
+
+    def __init__(self, result: Optional[ConeToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_ConeToolEntityInfo 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) -> ConeToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return ConeToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: ConeToolEntityInfoRef) -> 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_EllipseToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_EllipseToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .EllipseToolEntityInfoRef import EllipseToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_EllipseToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_EllipseToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_EllipseToolEntityInfo
+
+
+    def __init__(self, result: Optional[EllipseToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_EllipseToolEntityInfo 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) -> EllipseToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return EllipseToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: EllipseToolEntityInfoRef) -> 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_FoldEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_FoldEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .FoldEntityInfoRef import FoldEntityInfoRef
+
+class ValidatableResult_ProtoReference_FoldEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_FoldEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_FoldEntityInfo
+
+
+    def __init__(self, result: Optional[FoldEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_FoldEntityInfo 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) -> FoldEntityInfoRef:
+        """Get the Result field as a reference."""
+        return FoldEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: FoldEntityInfoRef) -> 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_LineIntersectionCalculatorToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_LineIntersectionCalculatorToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .LineIntersectionCalculatorToolEntityInfoRef import LineIntersectionCalculatorToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_LineIntersectionCalculatorToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_LineIntersectionCalculatorToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_LineIntersectionCalculatorToolEntityInfo
+
+
+    def __init__(self, result: Optional[LineIntersectionCalculatorToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_LineIntersectionCalculatorToolEntityInfo 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) -> LineIntersectionCalculatorToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return LineIntersectionCalculatorToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: LineIntersectionCalculatorToolEntityInfoRef) -> 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_LineToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_LineToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .LineToolEntityInfoRef import LineToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_LineToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_LineToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_LineToolEntityInfo
+
+
+    def __init__(self, result: Optional[LineToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_LineToolEntityInfo 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) -> LineToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return LineToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: LineToolEntityInfoRef) -> 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_MeasureAngleToolEntityInfoVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_MeasureAngleToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .MeasureAngleToolEntityInfoRef import MeasureAngleToolEntityInfoRef
+
+class ValidatableResult_ProtoReference_MeasureAngleToolEntityInfoVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_MeasureAngleToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_MeasureAngleToolEntityInfo
+
+
+    def __init__(self, result: Optional[MeasureAngleToolEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_MeasureAngleToolEntityInfo 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) -> MeasureAngleToolEntityInfoRef:
+        """Get the Result field as a reference."""
+        return MeasureAngleToolEntityInfoRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: MeasureAngleToolEntityInfoRef) -> 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_OrientationDataSetVal.py

@@ -0,0 +1,86 @@
+"""Generated wrapper for ValidatableResult_ProtoReference_OrientationDataSet protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ValidationErrorVal import ValidationErrorVal
+from .OrientationDataSetRef import OrientationDataSetRef
+
+class ValidatableResult_ProtoReference_OrientationDataSetVal:
+    """Simple wrapper for ValidatableResult_ProtoReference_OrientationDataSet with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ValidatableResult_ProtoReference_OrientationDataSet
+
+
+    def __init__(self, result: Optional[OrientationDataSetRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ValidatableResult_ProtoReference_OrientationDataSet 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) -> OrientationDataSetRef:
+        """Get the Result field as a reference."""
+        return OrientationDataSetRef(self.__channelToConnectOn, self._proto_message.Result)
+    
+    @result.setter
+    def result(self, value: OrientationDataSetRef) -> 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})"