DipsScripting 9.1.0__py3-none-any.whl

dips/JointFrequencyAnalysisSettingsVal.py

@@ -0,0 +1,102 @@
+"""Generated wrapper for JointFrequencyAnalysisSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .IntervalVal import IntervalVal
+from .OrientationDataSetRef import OrientationDataSetRef
+
+class JointFrequencyAnalysisSettingsVal:
+    """Simple wrapper for JointFrequencyAnalysisSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.JointFrequencyAnalysisSettings
+
+
+    def __init__(self, interval: Optional[IntervalVal] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the JointFrequencyAnalysisSettings 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 interval is not None:
+            self._proto_message.Interval.CopyFrom(interval.to_proto())
+            self._interval_wrapper = interval
+
+
+    # Properties
+
+    @property
+    def interval(self) -> IntervalVal:
+        """Get the Interval field as a wrapper."""
+        if not hasattr(self, '_interval_wrapper'):
+            self._interval_wrapper = IntervalVal(proto_message=self._proto_message.Interval)
+        return self._interval_wrapper
+    
+    @interval.setter
+    def interval(self, value: IntervalVal) -> None:
+        """Set the Interval field to a wrapper."""
+        self._proto_message.Interval.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_interval_wrapper'):
+            self._interval_wrapper._proto_message.CopyFrom(self._proto_message.Interval)
+
+
+    @property
+    def traverses(self) -> List[OrientationDataSetRef]:
+        """Get the Traverses field as a list."""
+        return _ProtobufListWrapper(self._proto_message.Traverses)
+    
+    @traverses.setter
+    def traverses(self, value: List[OrientationDataSetRef]) -> None:
+        """Set the Traverses field to a list."""
+        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.Traverses[:] = []
+        self._proto_message.Traverses.extend(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/JointFrequencyChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .JointFrequencyChartViewVal import JointFrequencyChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class JointFrequencyChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_JointFrequencyChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__JointFrequencyChartServicesStubLocal = DipsAPI_pb2_grpc.JointFrequencyChartServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> JointFrequencyChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.JointFrequencyChartView()
+        ret.MergeFromString(bytes.data)
+        return JointFrequencyChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseJointFrequencyChartView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_JointFrequencyChartView(This=self.__modelRef)
+        ret = self.__JointFrequencyChartServicesStubLocal.CloseJointFrequencyChartView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_JointFrequencyChartView(This=self.__modelRef)
+        ret = self.__JointFrequencyChartServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_JointFrequencyChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__JointFrequencyChartServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+ 

dips/JointFrequencyChartViewVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for JointFrequencyChartView protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .JointFrequencyAnalysisSettingsVal import JointFrequencyAnalysisSettingsVal
+from .DataFilterRef import DataFilterRef
+
+class JointFrequencyChartViewVal:
+    """Simple wrapper for JointFrequencyChartView with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.JointFrequencyChartView
+
+
+    def __init__(self, joint_frequency_analysis_settings: Optional[JointFrequencyAnalysisSettingsVal] = None, active_filter: Optional[DataFilterRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the JointFrequencyChartView 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 joint_frequency_analysis_settings is not None:
+            self._proto_message.JointFrequencyAnalysisSettings.CopyFrom(joint_frequency_analysis_settings.to_proto())
+            self._joint_frequency_analysis_settings_wrapper = joint_frequency_analysis_settings
+        if active_filter is not None:
+            self.active_filter = active_filter
+
+
+    # Properties
+
+    @property
+    def view_name(self) -> str:
+        """Get the ViewName field value."""
+        return self._proto_message.ViewName
+    
+    @view_name.setter
+    def view_name(self, value: str) -> None:
+        """Set the ViewName field value."""
+        self._proto_message.ViewName = value
+
+
+    @property
+    def joint_frequency_analysis_settings(self) -> JointFrequencyAnalysisSettingsVal:
+        """Get the JointFrequencyAnalysisSettings field as a wrapper."""
+        if not hasattr(self, '_joint_frequency_analysis_settings_wrapper'):
+            self._joint_frequency_analysis_settings_wrapper = JointFrequencyAnalysisSettingsVal(proto_message=self._proto_message.JointFrequencyAnalysisSettings)
+        return self._joint_frequency_analysis_settings_wrapper
+    
+    @joint_frequency_analysis_settings.setter
+    def joint_frequency_analysis_settings(self, value: JointFrequencyAnalysisSettingsVal) -> None:
+        """Set the JointFrequencyAnalysisSettings field to a wrapper."""
+        self._proto_message.JointFrequencyAnalysisSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_joint_frequency_analysis_settings_wrapper'):
+            self._joint_frequency_analysis_settings_wrapper._proto_message.CopyFrom(self._proto_message.JointFrequencyAnalysisSettings)
+
+
+    @property
+    def active_filter(self) -> DataFilterRef:
+        """Get the ActiveFilter field as a reference."""
+        return DataFilterRef(self.__channelToConnectOn, self._proto_message.ActiveFilter)
+    
+    @active_filter.setter
+    def active_filter(self, value: DataFilterRef) -> None:
+        """Set the ActiveFilter field to a reference."""
+        self._proto_message.ActiveFilter.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/JointSpacingAnalysisSettingsVal.py

@@ -0,0 +1,138 @@
+"""Generated wrapper for JointSpacingAnalysisSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .CustomHistogramOptionsVal import CustomHistogramOptionsVal
+from .OrientationDataSetRef import OrientationDataSetRef
+from .SetEntityInfoRef import SetEntityInfoRef
+
+class JointSpacingAnalysisSettingsVal:
+    """Simple wrapper for JointSpacingAnalysisSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.JointSpacingAnalysisSettings
+
+
+    def __init__(self, set: Optional[SetEntityInfoRef] = None, custom_options: Optional[CustomHistogramOptionsVal] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the JointSpacingAnalysisSettings 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 set is not None:
+            self.set = set
+        if custom_options is not None:
+            self._proto_message.CustomOptions.CopyFrom(custom_options.to_proto())
+            self._custom_options_wrapper = custom_options
+
+
+    # Properties
+
+    @property
+    def spacing_option(self) -> Any:
+        """Get the SpacingOption field value."""
+        return self._proto_message.SpacingOption
+    
+    @spacing_option.setter
+    def spacing_option(self, value: Any) -> None:
+        """Set the SpacingOption field value."""
+        self._proto_message.SpacingOption = value
+
+
+    @property
+    def set(self) -> SetEntityInfoRef:
+        """Get the Set field as a reference."""
+        return SetEntityInfoRef(self.__channelToConnectOn, self._proto_message.Set)
+    
+    @set.setter
+    def set(self, value: SetEntityInfoRef) -> None:
+        """Set the Set field to a reference."""
+        self._proto_message.Set.CopyFrom(value.get_model_ref())
+
+
+    @property
+    def traverses(self) -> List[OrientationDataSetRef]:
+        """Get the Traverses field as a list."""
+        return _ProtobufListWrapper(self._proto_message.Traverses)
+    
+    @traverses.setter
+    def traverses(self, value: List[OrientationDataSetRef]) -> None:
+        """Set the Traverses field to a list."""
+        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.Traverses[:] = []
+        self._proto_message.Traverses.extend(value)
+
+
+    @property
+    def num_intervals(self) -> int:
+        """Get the NumIntervals field value."""
+        return self._proto_message.NumIntervals
+    
+    @num_intervals.setter
+    def num_intervals(self, value: int) -> None:
+        """Set the NumIntervals field value."""
+        self._proto_message.NumIntervals = value
+
+
+    @property
+    def show_best_fit_distribution(self) -> bool:
+        """Get the ShowBestFitDistribution field value."""
+        return self._proto_message.ShowBestFitDistribution
+    
+    @show_best_fit_distribution.setter
+    def show_best_fit_distribution(self, value: bool) -> None:
+        """Set the ShowBestFitDistribution field value."""
+        self._proto_message.ShowBestFitDistribution = value
+
+
+    @property
+    def custom_options(self) -> CustomHistogramOptionsVal:
+        """Get the CustomOptions field as a wrapper."""
+        if not hasattr(self, '_custom_options_wrapper'):
+            self._custom_options_wrapper = CustomHistogramOptionsVal(proto_message=self._proto_message.CustomOptions)
+        return self._custom_options_wrapper
+    
+    @custom_options.setter
+    def custom_options(self, value: CustomHistogramOptionsVal) -> None:
+        """Set the CustomOptions field to a wrapper."""
+        self._proto_message.CustomOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_custom_options_wrapper'):
+            self._custom_options_wrapper._proto_message.CopyFrom(self._proto_message.CustomOptions)
+
+
+    # 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/JointSpacingChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .JointSpacingChartViewVal import JointSpacingChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class JointSpacingChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_JointSpacingChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__JointSpacingChartServicesStubLocal = DipsAPI_pb2_grpc.JointSpacingChartServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> JointSpacingChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.JointSpacingChartView()
+        ret.MergeFromString(bytes.data)
+        return JointSpacingChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseJointSpacingChartView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_JointSpacingChartView(This=self.__modelRef)
+        ret = self.__JointSpacingChartServicesStubLocal.CloseJointSpacingChartView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_JointSpacingChartView(This=self.__modelRef)
+        ret = self.__JointSpacingChartServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_JointSpacingChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__JointSpacingChartServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+ 

dips/JointSpacingChartViewVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for JointSpacingChartView protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .JointSpacingAnalysisSettingsVal import JointSpacingAnalysisSettingsVal
+from .DataFilterRef import DataFilterRef
+
+class JointSpacingChartViewVal:
+    """Simple wrapper for JointSpacingChartView with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.JointSpacingChartView
+
+
+    def __init__(self, joint_spacing_analysis_settings: Optional[JointSpacingAnalysisSettingsVal] = None, active_filter: Optional[DataFilterRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the JointSpacingChartView 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 joint_spacing_analysis_settings is not None:
+            self._proto_message.JointSpacingAnalysisSettings.CopyFrom(joint_spacing_analysis_settings.to_proto())
+            self._joint_spacing_analysis_settings_wrapper = joint_spacing_analysis_settings
+        if active_filter is not None:
+            self.active_filter = active_filter
+
+
+    # Properties
+
+    @property
+    def view_name(self) -> str:
+        """Get the ViewName field value."""
+        return self._proto_message.ViewName
+    
+    @view_name.setter
+    def view_name(self, value: str) -> None:
+        """Set the ViewName field value."""
+        self._proto_message.ViewName = value
+
+
+    @property
+    def joint_spacing_analysis_settings(self) -> JointSpacingAnalysisSettingsVal:
+        """Get the JointSpacingAnalysisSettings field as a wrapper."""
+        if not hasattr(self, '_joint_spacing_analysis_settings_wrapper'):
+            self._joint_spacing_analysis_settings_wrapper = JointSpacingAnalysisSettingsVal(proto_message=self._proto_message.JointSpacingAnalysisSettings)
+        return self._joint_spacing_analysis_settings_wrapper
+    
+    @joint_spacing_analysis_settings.setter
+    def joint_spacing_analysis_settings(self, value: JointSpacingAnalysisSettingsVal) -> None:
+        """Set the JointSpacingAnalysisSettings field to a wrapper."""
+        self._proto_message.JointSpacingAnalysisSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_joint_spacing_analysis_settings_wrapper'):
+            self._joint_spacing_analysis_settings_wrapper._proto_message.CopyFrom(self._proto_message.JointSpacingAnalysisSettings)
+
+
+    @property
+    def active_filter(self) -> DataFilterRef:
+        """Get the ActiveFilter field as a reference."""
+        return DataFilterRef(self.__channelToConnectOn, self._proto_message.ActiveFilter)
+    
+    @active_filter.setter
+    def active_filter(self, value: DataFilterRef) -> None:
+        """Set the ActiveFilter field to a reference."""
+        self._proto_message.ActiveFilter.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/KinematicAnalysisEntityVisibilityVal.py

@@ -0,0 +1,73 @@
+"""Generated wrapper for KinematicAnalysisEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class KinematicAnalysisEntityVisibilityVal:
+    """Simple wrapper for KinematicAnalysisEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.KinematicAnalysisEntityVisibility
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the KinematicAnalysisEntityVisibility 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 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 highlight_critical_vectors(self) -> bool:
+        """Get the HighlightCriticalVectors field value."""
+        return self._proto_message.HighlightCriticalVectors
+    
+    @highlight_critical_vectors.setter
+    def highlight_critical_vectors(self, value: bool) -> None:
+        """Set the HighlightCriticalVectors field value."""
+        self._proto_message.HighlightCriticalVectors = 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})"