DipsScripting 9.1.0__py3-none-any.whl

dips/ScatterPlotSettingsVal.py

@@ -0,0 +1,113 @@
+"""Generated wrapper for ScatterPlotSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .DataDescriptorVal import DataDescriptorVal
+
+class ScatterPlotSettingsVal:
+    """Simple wrapper for ScatterPlotSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ScatterPlotSettings
+
+
+    def __init__(self, selected_column_x: Optional[DataDescriptorVal] = None, selected_column_y: Optional[DataDescriptorVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the ScatterPlotSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if selected_column_x is not None:
+            self._proto_message.SelectedColumnX.CopyFrom(selected_column_x.to_proto())
+            self._selected_column_x_wrapper = selected_column_x
+        if selected_column_y is not None:
+            self._proto_message.SelectedColumnY.CopyFrom(selected_column_y.to_proto())
+            self._selected_column_y_wrapper = selected_column_y
+
+
+    # Properties
+
+    @property
+    def selected_column_x(self) -> DataDescriptorVal:
+        """Get the SelectedColumnX field as a wrapper."""
+        if not hasattr(self, '_selected_column_x_wrapper'):
+            self._selected_column_x_wrapper = DataDescriptorVal(proto_message=self._proto_message.SelectedColumnX)
+        return self._selected_column_x_wrapper
+    
+    @selected_column_x.setter
+    def selected_column_x(self, value: DataDescriptorVal) -> None:
+        """Set the SelectedColumnX field to a wrapper."""
+        self._proto_message.SelectedColumnX.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_selected_column_x_wrapper'):
+            self._selected_column_x_wrapper._proto_message.CopyFrom(self._proto_message.SelectedColumnX)
+
+
+    @property
+    def selected_column_y(self) -> DataDescriptorVal:
+        """Get the SelectedColumnY field as a wrapper."""
+        if not hasattr(self, '_selected_column_y_wrapper'):
+            self._selected_column_y_wrapper = DataDescriptorVal(proto_message=self._proto_message.SelectedColumnY)
+        return self._selected_column_y_wrapper
+    
+    @selected_column_y.setter
+    def selected_column_y(self, value: DataDescriptorVal) -> None:
+        """Set the SelectedColumnY field to a wrapper."""
+        self._proto_message.SelectedColumnY.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_selected_column_y_wrapper'):
+            self._selected_column_y_wrapper._proto_message.CopyFrom(self._proto_message.SelectedColumnY)
+
+
+    @property
+    def show_regression_line(self) -> bool:
+        """Get the ShowRegressionLine field value."""
+        return self._proto_message.ShowRegressionLine
+    
+    @show_regression_line.setter
+    def show_regression_line(self, value: bool) -> None:
+        """Set the ShowRegressionLine field value."""
+        self._proto_message.ShowRegressionLine = value
+
+
+    @property
+    def is_weighted(self) -> bool:
+        """Get the IsWeighted field value."""
+        return self._proto_message.IsWeighted
+    
+    @is_weighted.setter
+    def is_weighted(self, value: bool) -> None:
+        """Set the IsWeighted field value."""
+        self._proto_message.IsWeighted = value
+
+
+    # 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/SetEntityInfoRef.py

@@ -0,0 +1,23 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .SetEntityInfoVal import SetEntityInfoVal
+
+class SetEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_SetEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        
+    
+    def GetValue(self) -> SetEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.SetEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return SetEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+ 

dips/SetEntityInfoVal.py

@@ -0,0 +1,103 @@
+"""Generated wrapper for SetEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+from .SetWindowEntityInfoVal import SetWindowEntityInfoVal
+
+class SetEntityInfoVal:
+    """Simple wrapper for SetEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetEntityInfo
+
+
+    def __init__(self, color: Optional[ColorSurrogateVal] = None, set_window_entity_info: Optional[SetWindowEntityInfoVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the SetEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if color is not None:
+            self._proto_message.Color.CopyFrom(color.to_proto())
+            self._color_wrapper = color
+        if set_window_entity_info is not None:
+            self._proto_message.SetWindowEntityInfo.CopyFrom(set_window_entity_info.to_proto())
+            self._set_window_entity_info_wrapper = set_window_entity_info
+
+
+    # Properties
+
+    @property
+    def id(self) -> str:
+        """Get the ID field value."""
+        return self._proto_message.ID
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        """Set the ID field value."""
+        self._proto_message.ID = value
+
+
+    @property
+    def color(self) -> ColorSurrogateVal:
+        """Get the Color field as a wrapper."""
+        if not hasattr(self, '_color_wrapper'):
+            self._color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.Color)
+        return self._color_wrapper
+    
+    @color.setter
+    def color(self, value: ColorSurrogateVal) -> None:
+        """Set the Color field to a wrapper."""
+        self._proto_message.Color.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_color_wrapper'):
+            self._color_wrapper._proto_message.CopyFrom(self._proto_message.Color)
+
+
+    @property
+    def set_window_entity_info(self) -> SetWindowEntityInfoVal:
+        """Get the SetWindowEntityInfo field as a wrapper."""
+        if not hasattr(self, '_set_window_entity_info_wrapper'):
+            self._set_window_entity_info_wrapper = SetWindowEntityInfoVal(proto_message=self._proto_message.SetWindowEntityInfo)
+        return self._set_window_entity_info_wrapper
+    
+    @set_window_entity_info.setter
+    def set_window_entity_info(self, value: SetWindowEntityInfoVal) -> None:
+        """Set the SetWindowEntityInfo field to a wrapper."""
+        self._proto_message.SetWindowEntityInfo.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_set_window_entity_info_wrapper'):
+            self._set_window_entity_info_wrapper._proto_message.CopyFrom(self._proto_message.SetWindowEntityInfo)
+
+
+    # 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/SetEntityOptionsVal.py

@@ -0,0 +1,133 @@
+"""Generated wrapper for SetEntityOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+from .PlaneOptionsVal import PlaneOptionsVal
+
+class SetEntityOptionsVal:
+    """Simple wrapper for SetEntityOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetEntityOptions
+
+
+    def __init__(self, plane_options: Optional[PlaneOptionsVal] = None, confidence_cone_color: Optional[ColorSurrogateVal] = None, variability_cone_color: Optional[ColorSurrogateVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the SetEntityOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if plane_options is not None:
+            self._proto_message.PlaneOptions.CopyFrom(plane_options.to_proto())
+            self._plane_options_wrapper = plane_options
+        if confidence_cone_color is not None:
+            self._proto_message.ConfidenceConeColor.CopyFrom(confidence_cone_color.to_proto())
+            self._confidence_cone_color_wrapper = confidence_cone_color
+        if variability_cone_color is not None:
+            self._proto_message.VariabilityConeColor.CopyFrom(variability_cone_color.to_proto())
+            self._variability_cone_color_wrapper = variability_cone_color
+
+
+    # Properties
+
+    @property
+    def plane_options(self) -> PlaneOptionsVal:
+        """Get the PlaneOptions field as a wrapper."""
+        if not hasattr(self, '_plane_options_wrapper'):
+            self._plane_options_wrapper = PlaneOptionsVal(proto_message=self._proto_message.PlaneOptions)
+        return self._plane_options_wrapper
+    
+    @plane_options.setter
+    def plane_options(self, value: PlaneOptionsVal) -> None:
+        """Set the PlaneOptions field to a wrapper."""
+        self._proto_message.PlaneOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_plane_options_wrapper'):
+            self._plane_options_wrapper._proto_message.CopyFrom(self._proto_message.PlaneOptions)
+
+
+    @property
+    def show_confidence_cones(self) -> bool:
+        """Get the ShowConfidenceCones field value."""
+        return self._proto_message.ShowConfidenceCones
+    
+    @show_confidence_cones.setter
+    def show_confidence_cones(self, value: bool) -> None:
+        """Set the ShowConfidenceCones field value."""
+        self._proto_message.ShowConfidenceCones = value
+
+
+    @property
+    def confidence_cone_color(self) -> ColorSurrogateVal:
+        """Get the ConfidenceConeColor field as a wrapper."""
+        if not hasattr(self, '_confidence_cone_color_wrapper'):
+            self._confidence_cone_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.ConfidenceConeColor)
+        return self._confidence_cone_color_wrapper
+    
+    @confidence_cone_color.setter
+    def confidence_cone_color(self, value: ColorSurrogateVal) -> None:
+        """Set the ConfidenceConeColor field to a wrapper."""
+        self._proto_message.ConfidenceConeColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_confidence_cone_color_wrapper'):
+            self._confidence_cone_color_wrapper._proto_message.CopyFrom(self._proto_message.ConfidenceConeColor)
+
+
+    @property
+    def show_variability_cones(self) -> bool:
+        """Get the ShowVariabilityCones field value."""
+        return self._proto_message.ShowVariabilityCones
+    
+    @show_variability_cones.setter
+    def show_variability_cones(self, value: bool) -> None:
+        """Set the ShowVariabilityCones field value."""
+        self._proto_message.ShowVariabilityCones = value
+
+
+    @property
+    def variability_cone_color(self) -> ColorSurrogateVal:
+        """Get the VariabilityConeColor field as a wrapper."""
+        if not hasattr(self, '_variability_cone_color_wrapper'):
+            self._variability_cone_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.VariabilityConeColor)
+        return self._variability_cone_color_wrapper
+    
+    @variability_cone_color.setter
+    def variability_cone_color(self, value: ColorSurrogateVal) -> None:
+        """Set the VariabilityConeColor field to a wrapper."""
+        self._proto_message.VariabilityConeColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_variability_cone_color_wrapper'):
+            self._variability_cone_color_wrapper._proto_message.CopyFrom(self._proto_message.VariabilityConeColor)
+
+
+    # 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/SetEntityVisibilityRef.py

@@ -0,0 +1,38 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .SetEntityVisibilityVal import SetEntityVisibilityVal
+from .SetEntityVisibilityVal import SetEntityVisibilityVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class SetEntityVisibilityRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_SetEntityVisibility):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> SetEntityVisibilityVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.SetEntityVisibility()
+        ret.MergeFromString(bytes.data)
+        return SetEntityVisibilityVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def SetMeanSetPlaneEntityOptions(self,  SetEntityVisibility: SetEntityVisibilityVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_SetEntityVisibility_SetEntityVisibility(This=self.__modelRef,  Input1=(SetEntityVisibility.to_proto() if hasattr(SetEntityVisibility, 'to_proto') else SetEntityVisibility))
+        ret = self.__EntityServicesStubLocal.SetMeanSetPlaneEntityOptions(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+    def SetMeanSetPlaneEntityVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_SetEntityVisibility_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetMeanSetPlaneEntityVisibility(functionParam)
+        
+
+ 

dips/SetEntityVisibilityVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for SetEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .SetEntityOptionsVal import SetEntityOptionsVal
+from .SetEntityInfoRef import SetEntityInfoRef
+
+class SetEntityVisibilityVal:
+    """Simple wrapper for SetEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetEntityVisibility
+
+
+    def __init__(self, options: Optional[SetEntityOptionsVal] = None, set_entity_reference: Optional[SetEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the SetEntityVisibility 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 options is not None:
+            self._proto_message.Options.CopyFrom(options.to_proto())
+            self._options_wrapper = options
+        if set_entity_reference is not None:
+            self.set_entity_reference = set_entity_reference
+
+
+    # Properties
+
+    @property
+    def is_visible(self) -> bool:
+        """Get the IsVisible field value."""
+        return self._proto_message.IsVisible
+    
+    @is_visible.setter
+    def is_visible(self, value: bool) -> None:
+        """Set the IsVisible field value."""
+        self._proto_message.IsVisible = value
+
+
+    @property
+    def options(self) -> SetEntityOptionsVal:
+        """Get the Options field as a wrapper."""
+        if not hasattr(self, '_options_wrapper'):
+            self._options_wrapper = SetEntityOptionsVal(proto_message=self._proto_message.Options)
+        return self._options_wrapper
+    
+    @options.setter
+    def options(self, value: SetEntityOptionsVal) -> None:
+        """Set the Options field to a wrapper."""
+        self._proto_message.Options.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_options_wrapper'):
+            self._options_wrapper._proto_message.CopyFrom(self._proto_message.Options)
+
+
+    @property
+    def set_entity_reference(self) -> SetEntityInfoRef:
+        """Get the SetEntityReference field as a reference."""
+        return SetEntityInfoRef(self.__channelToConnectOn, self._proto_message.SetEntityReference)
+    
+    @set_entity_reference.setter
+    def set_entity_reference(self, value: SetEntityInfoRef) -> None:
+        """Set the SetEntityReference field to a reference."""
+        self._proto_message.SetEntityReference.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/SetStatisticsSettingsVal.py

@@ -0,0 +1,106 @@
+"""Generated wrapper for SetStatisticsSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class SetStatisticsSettingsVal:
+    """Simple wrapper for SetStatisticsSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetStatisticsSettings
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the SetStatisticsSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+
+
+    # Properties
+
+    @property
+    def one_std_dev(self) -> bool:
+        """Get the OneStdDev field value."""
+        return self._proto_message.OneStdDev
+    
+    @one_std_dev.setter
+    def one_std_dev(self, value: bool) -> None:
+        """Set the OneStdDev field value."""
+        self._proto_message.OneStdDev = value
+
+
+    @property
+    def two_std_dev(self) -> bool:
+        """Get the TwoStdDev field value."""
+        return self._proto_message.TwoStdDev
+    
+    @two_std_dev.setter
+    def two_std_dev(self, value: bool) -> None:
+        """Set the TwoStdDev field value."""
+        self._proto_message.TwoStdDev = value
+
+
+    @property
+    def three_std_dev(self) -> bool:
+        """Get the ThreeStdDev field value."""
+        return self._proto_message.ThreeStdDev
+    
+    @three_std_dev.setter
+    def three_std_dev(self, value: bool) -> None:
+        """Set the ThreeStdDev field value."""
+        self._proto_message.ThreeStdDev = value
+
+
+    @property
+    def use_custom_interval(self) -> bool:
+        """Get the UseCustomInterval field value."""
+        return self._proto_message.UseCustomInterval
+    
+    @use_custom_interval.setter
+    def use_custom_interval(self, value: bool) -> None:
+        """Set the UseCustomInterval field value."""
+        self._proto_message.UseCustomInterval = value
+
+
+    @property
+    def custom_interval(self) -> float:
+        """Get the CustomInterval field value."""
+        return self._proto_message.CustomInterval
+    
+    @custom_interval.setter
+    def custom_interval(self, value: float) -> None:
+        """Set the CustomInterval field value."""
+        self._proto_message.CustomInterval = value
+
+
+    # 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})"