DipsScripting 9.1.0__py3-none-any.whl

dips/QualitativeQuantitativeAnalysisSettingsVal.py

@@ -0,0 +1,151 @@
+"""Generated wrapper for QualitativeQuantitativeAnalysisSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .CustomRangeVal import CustomRangeVal
+from .DataDescriptorVal import DataDescriptorVal
+
+class QualitativeQuantitativeAnalysisSettingsVal:
+    """Simple wrapper for QualitativeQuantitativeAnalysisSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.QualitativeQuantitativeAnalysisSettings
+
+
+    def __init__(self, custom_range: Optional[CustomRangeVal] = None, selected_column: Optional[DataDescriptorVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the QualitativeQuantitativeAnalysisSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if custom_range is not None:
+            self._proto_message.CustomRange.CopyFrom(custom_range.to_proto())
+            self._custom_range_wrapper = custom_range
+        if selected_column is not None:
+            self._proto_message.SelectedColumn.CopyFrom(selected_column.to_proto())
+            self._selected_column_wrapper = selected_column
+
+
+    # Properties
+
+    @property
+    def analysis_type(self) -> Any:
+        """Get the AnalysisType field value."""
+        return self._proto_message.AnalysisType
+    
+    @analysis_type.setter
+    def analysis_type(self, value: Any) -> None:
+        """Set the AnalysisType field value."""
+        self._proto_message.AnalysisType = value
+
+
+    @property
+    def allocated_items(self) -> list:
+        """Get the AllocatedItems field as a list."""
+        return _ProtobufListWrapper(self._proto_message.AllocatedItems)
+    
+    @allocated_items.setter
+    def allocated_items(self, value: list) -> None:
+        """Set the AllocatedItems 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.AllocatedItems[:] = []
+        self._proto_message.AllocatedItems.extend(value)
+
+
+    @property
+    def custom_range(self) -> CustomRangeVal:
+        """Get the CustomRange field as a wrapper."""
+        if not hasattr(self, '_custom_range_wrapper'):
+            self._custom_range_wrapper = CustomRangeVal(proto_message=self._proto_message.CustomRange)
+        return self._custom_range_wrapper
+    
+    @custom_range.setter
+    def custom_range(self, value: CustomRangeVal) -> None:
+        """Set the CustomRange field to a wrapper."""
+        self._proto_message.CustomRange.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_custom_range_wrapper'):
+            self._custom_range_wrapper._proto_message.CopyFrom(self._proto_message.CustomRange)
+
+
+    @property
+    def num_bins(self) -> int:
+        """Get the NumBins field value."""
+        return self._proto_message.NumBins
+    
+    @num_bins.setter
+    def num_bins(self, value: int) -> None:
+        """Set the NumBins field value."""
+        self._proto_message.NumBins = value
+
+
+    @property
+    def logarithmic(self) -> bool:
+        """Get the Logarithmic field value."""
+        return self._proto_message.Logarithmic
+    
+    @logarithmic.setter
+    def logarithmic(self, value: bool) -> None:
+        """Set the Logarithmic field value."""
+        self._proto_message.Logarithmic = value
+
+
+    @property
+    def selected_column(self) -> DataDescriptorVal:
+        """Get the SelectedColumn field as a wrapper."""
+        if not hasattr(self, '_selected_column_wrapper'):
+            self._selected_column_wrapper = DataDescriptorVal(proto_message=self._proto_message.SelectedColumn)
+        return self._selected_column_wrapper
+    
+    @selected_column.setter
+    def selected_column(self, value: DataDescriptorVal) -> None:
+        """Set the SelectedColumn field to a wrapper."""
+        self._proto_message.SelectedColumn.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_selected_column_wrapper'):
+            self._selected_column_wrapper._proto_message.CopyFrom(self._proto_message.SelectedColumn)
+
+
+    @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/QualitativeQuantitativeChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .QualitativeQuantitativeChartViewVal import QualitativeQuantitativeChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class QualitativeQuantitativeChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_QualitativeQuantitativeChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__QualitativeQuantitativeChartServicesStubLocal = DipsAPI_pb2_grpc.QualitativeQuantitativeChartServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> QualitativeQuantitativeChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.QualitativeQuantitativeChartView()
+        ret.MergeFromString(bytes.data)
+        return QualitativeQuantitativeChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseQualitativeQuantitativeChartView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_QualitativeQuantitativeChartView(This=self.__modelRef)
+        ret = self.__QualitativeQuantitativeChartServicesStubLocal.CloseQualitativeQuantitativeChartView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_QualitativeQuantitativeChartView(This=self.__modelRef)
+        ret = self.__QualitativeQuantitativeChartServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_QualitativeQuantitativeChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__QualitativeQuantitativeChartServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+ 

dips/QualitativeQuantitativeChartViewVal.py

@@ -0,0 +1,111 @@
+"""Generated wrapper for QualitativeQuantitativeChartView protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .QualitativeQuantitativeAnalysisSettingsVal import QualitativeQuantitativeAnalysisSettingsVal
+from .DataFilterRef import DataFilterRef
+
+class QualitativeQuantitativeChartViewVal:
+    """Simple wrapper for QualitativeQuantitativeChartView with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.QualitativeQuantitativeChartView
+
+
+    def __init__(self, qualitative_quantitative_analysis_settings: Optional[QualitativeQuantitativeAnalysisSettingsVal] = None, active_filter: Optional[DataFilterRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the QualitativeQuantitativeChartView 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 qualitative_quantitative_analysis_settings is not None:
+            self._proto_message.QualitativeQuantitativeAnalysisSettings.CopyFrom(qualitative_quantitative_analysis_settings.to_proto())
+            self._qualitative_quantitative_analysis_settings_wrapper = qualitative_quantitative_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 qualitative_quantitative_analysis_settings(self) -> QualitativeQuantitativeAnalysisSettingsVal:
+        """Get the QualitativeQuantitativeAnalysisSettings field as a wrapper."""
+        if not hasattr(self, '_qualitative_quantitative_analysis_settings_wrapper'):
+            self._qualitative_quantitative_analysis_settings_wrapper = QualitativeQuantitativeAnalysisSettingsVal(proto_message=self._proto_message.QualitativeQuantitativeAnalysisSettings)
+        return self._qualitative_quantitative_analysis_settings_wrapper
+    
+    @qualitative_quantitative_analysis_settings.setter
+    def qualitative_quantitative_analysis_settings(self, value: QualitativeQuantitativeAnalysisSettingsVal) -> None:
+        """Set the QualitativeQuantitativeAnalysisSettings field to a wrapper."""
+        self._proto_message.QualitativeQuantitativeAnalysisSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_qualitative_quantitative_analysis_settings_wrapper'):
+            self._qualitative_quantitative_analysis_settings_wrapper._proto_message.CopyFrom(self._proto_message.QualitativeQuantitativeAnalysisSettings)
+
+
+    @property
+    def chart_type(self) -> Any:
+        """Get the ChartType field value."""
+        return self._proto_message.ChartType
+    
+    @chart_type.setter
+    def chart_type(self, value: Any) -> None:
+        """Set the ChartType field value."""
+        self._proto_message.ChartType = value
+
+
+    @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/QuantitativeContourSettingsVal.py

@@ -0,0 +1,103 @@
+"""Generated wrapper for QuantitativeContourSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+from .DataDescriptorVal import DataDescriptorVal
+
+class QuantitativeContourSettingsVal:
+    """Simple wrapper for QuantitativeContourSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.QuantitativeContourSettings
+
+
+    def __init__(self, local_angle: Optional[AngleDataVal] = None, selected_column: Optional[DataDescriptorVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the QuantitativeContourSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if local_angle is not None:
+            self._proto_message.LocalAngle.CopyFrom(local_angle.to_proto())
+            self._local_angle_wrapper = local_angle
+        if selected_column is not None:
+            self._proto_message.SelectedColumn.CopyFrom(selected_column.to_proto())
+            self._selected_column_wrapper = selected_column
+
+
+    # Properties
+
+    @property
+    def interpolation(self) -> Any:
+        """Get the Interpolation field value."""
+        return self._proto_message.Interpolation
+    
+    @interpolation.setter
+    def interpolation(self, value: Any) -> None:
+        """Set the Interpolation field value."""
+        self._proto_message.Interpolation = value
+
+
+    @property
+    def local_angle(self) -> AngleDataVal:
+        """Get the LocalAngle field as a wrapper."""
+        if not hasattr(self, '_local_angle_wrapper'):
+            self._local_angle_wrapper = AngleDataVal(proto_message=self._proto_message.LocalAngle)
+        return self._local_angle_wrapper
+    
+    @local_angle.setter
+    def local_angle(self, value: AngleDataVal) -> None:
+        """Set the LocalAngle field to a wrapper."""
+        self._proto_message.LocalAngle.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_local_angle_wrapper'):
+            self._local_angle_wrapper._proto_message.CopyFrom(self._proto_message.LocalAngle)
+
+
+    @property
+    def selected_column(self) -> DataDescriptorVal:
+        """Get the SelectedColumn field as a wrapper."""
+        if not hasattr(self, '_selected_column_wrapper'):
+            self._selected_column_wrapper = DataDescriptorVal(proto_message=self._proto_message.SelectedColumn)
+        return self._selected_column_wrapper
+    
+    @selected_column.setter
+    def selected_column(self, value: DataDescriptorVal) -> None:
+        """Set the SelectedColumn field to a wrapper."""
+        self._proto_message.SelectedColumn.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_selected_column_wrapper'):
+            self._selected_column_wrapper._proto_message.CopyFrom(self._proto_message.SelectedColumn)
+
+
+    # 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/RQDAnalysisChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .RQDAnalysisChartViewVal import RQDAnalysisChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class RQDAnalysisChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_RQDAnalysisChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__RQDAnalysisChartServicesStubLocal = DipsAPI_pb2_grpc.RQDAnalysisChartServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> RQDAnalysisChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.RQDAnalysisChartView()
+        ret.MergeFromString(bytes.data)
+        return RQDAnalysisChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseRQDAnalysisChartView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RQDAnalysisChartView(This=self.__modelRef)
+        ret = self.__RQDAnalysisChartServicesStubLocal.CloseRQDAnalysisChartView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RQDAnalysisChartView(This=self.__modelRef)
+        ret = self.__RQDAnalysisChartServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RQDAnalysisChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__RQDAnalysisChartServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+ 

dips/RQDAnalysisChartViewVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for RQDAnalysisChartView protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .RQDAnalysisSettingsVal import RQDAnalysisSettingsVal
+from .DataFilterRef import DataFilterRef
+
+class RQDAnalysisChartViewVal:
+    """Simple wrapper for RQDAnalysisChartView with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.RQDAnalysisChartView
+
+
+    def __init__(self, rqd_analysis_settings: Optional[RQDAnalysisSettingsVal] = None, active_filter: Optional[DataFilterRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the RQDAnalysisChartView 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 rqd_analysis_settings is not None:
+            self._proto_message.RQDAnalysisSettings.CopyFrom(rqd_analysis_settings.to_proto())
+            self._rqd_analysis_settings_wrapper = rqd_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 rqd_analysis_settings(self) -> RQDAnalysisSettingsVal:
+        """Get the RQDAnalysisSettings field as a wrapper."""
+        if not hasattr(self, '_rqd_analysis_settings_wrapper'):
+            self._rqd_analysis_settings_wrapper = RQDAnalysisSettingsVal(proto_message=self._proto_message.RQDAnalysisSettings)
+        return self._rqd_analysis_settings_wrapper
+    
+    @rqd_analysis_settings.setter
+    def rqd_analysis_settings(self, value: RQDAnalysisSettingsVal) -> None:
+        """Set the RQDAnalysisSettings field to a wrapper."""
+        self._proto_message.RQDAnalysisSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_rqd_analysis_settings_wrapper'):
+            self._rqd_analysis_settings_wrapper._proto_message.CopyFrom(self._proto_message.RQDAnalysisSettings)
+
+
+    @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/RQDAnalysisSettingsVal.py

@@ -0,0 +1,111 @@
+"""Generated wrapper for RQDAnalysisSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .IntervalVal import IntervalVal
+from .LengthDataVal import LengthDataVal
+from .OrientationDataSetRef import OrientationDataSetRef
+
+class RQDAnalysisSettingsVal:
+    """Simple wrapper for RQDAnalysisSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.RQDAnalysisSettings
+
+
+    def __init__(self, interval: Optional[IntervalVal] = None, intact_core_cutoff_length: Optional[LengthDataVal] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the RQDAnalysisSettings 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
+        if intact_core_cutoff_length is not None:
+            self._proto_message.IntactCoreCutoffLength.CopyFrom(intact_core_cutoff_length.to_proto())
+            self._intact_core_cutoff_length_wrapper = intact_core_cutoff_length
+
+
+    # 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 intact_core_cutoff_length(self) -> LengthDataVal:
+        """Get the IntactCoreCutoffLength field as a wrapper."""
+        if not hasattr(self, '_intact_core_cutoff_length_wrapper'):
+            self._intact_core_cutoff_length_wrapper = LengthDataVal(proto_message=self._proto_message.IntactCoreCutoffLength)
+        return self._intact_core_cutoff_length_wrapper
+    
+    @intact_core_cutoff_length.setter
+    def intact_core_cutoff_length(self, value: LengthDataVal) -> None:
+        """Set the IntactCoreCutoffLength field to a wrapper."""
+        self._proto_message.IntactCoreCutoffLength.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_intact_core_cutoff_length_wrapper'):
+            self._intact_core_cutoff_length_wrapper._proto_message.CopyFrom(self._proto_message.IntactCoreCutoffLength)
+
+
+    @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)
+
+
+    # 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})"