DipsScripting 9.1.0__py3-none-any.whl

dips/GlobalPlaneEntityVisibilityVal.py

@@ -0,0 +1,103 @@
+"""Generated wrapper for GlobalPlaneEntityVisibility 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 GlobalPlaneEntityVisibilityVal:
+    """Simple wrapper for GlobalPlaneEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.GlobalPlaneEntityVisibility
+
+
+    def __init__(self, color: Optional[ColorSurrogateVal] = None, plane_options: Optional[PlaneOptionsVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the GlobalPlaneEntityVisibility 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 plane_options is not None:
+            self._proto_message.PlaneOptions.CopyFrom(plane_options.to_proto())
+            self._plane_options_wrapper = plane_options
+
+
+    # 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 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 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)
+
+
+    # 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/HistogramChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .HistogramChartViewVal import HistogramChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class HistogramChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_HistogramChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__HistogramServicesStubLocal = DipsAPI_pb2_grpc.HistogramServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> HistogramChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.HistogramChartView()
+        ret.MergeFromString(bytes.data)
+        return HistogramChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseHistogramView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_HistogramChartView(This=self.__modelRef)
+        ret = self.__HistogramServicesStubLocal.CloseHistogramView(functionParam)
+        
+
+    def GetActivePoleDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_HistogramChartView(This=self.__modelRef)
+        ret = self.__HistogramServicesStubLocal.GetActivePoleDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActivePoleDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_HistogramChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__HistogramServicesStubLocal.SetActivePoleDataFilter(functionParam)
+        
+
+ 

dips/HistogramChartViewVal.py

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

@@ -0,0 +1,136 @@
+"""Generated wrapper for HistogramPlotSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .CustomHistogramOptionsVal import CustomHistogramOptionsVal
+from .DataDescriptorVal import DataDescriptorVal
+
+class HistogramPlotSettingsVal:
+    """Simple wrapper for HistogramPlotSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.HistogramPlotSettings
+
+
+    def __init__(self, selected_column: Optional[DataDescriptorVal] = None, custom_options: Optional[CustomHistogramOptionsVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the HistogramPlotSettings 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 is not None:
+            self._proto_message.SelectedColumn.CopyFrom(selected_column.to_proto())
+            self._selected_column_wrapper = selected_column
+        if custom_options is not None:
+            self._proto_message.CustomOptions.CopyFrom(custom_options.to_proto())
+            self._custom_options_wrapper = custom_options
+
+
+    # Properties
+
+    @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 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 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 show_relative_frequency(self) -> bool:
+        """Get the ShowRelativeFrequency field value."""
+        return self._proto_message.ShowRelativeFrequency
+    
+    @show_relative_frequency.setter
+    def show_relative_frequency(self, value: bool) -> None:
+        """Set the ShowRelativeFrequency field value."""
+        self._proto_message.ShowRelativeFrequency = 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)
+
+
+    @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/IntersectionEntityVisibilityVal.py

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

@@ -0,0 +1,83 @@
+"""Generated wrapper for IntersectionOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .SetVersusSetVal import SetVersusSetVal
+
+class IntersectionOptionsVal:
+    """Simple wrapper for IntersectionOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.IntersectionOptions
+
+
+    def __init__(self, set_versus_set: Optional[SetVersusSetVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the IntersectionOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if set_versus_set is not None:
+            self._proto_message.SetVersusSet.CopyFrom(set_versus_set.to_proto())
+            self._set_versus_set_wrapper = set_versus_set
+
+
+    # Properties
+
+    @property
+    def intersection_type(self) -> Any:
+        """Get the IntersectionType field value."""
+        return self._proto_message.IntersectionType
+    
+    @intersection_type.setter
+    def intersection_type(self, value: Any) -> None:
+        """Set the IntersectionType field value."""
+        self._proto_message.IntersectionType = value
+
+
+    @property
+    def set_versus_set(self) -> SetVersusSetVal:
+        """Get the SetVersusSet field as a wrapper."""
+        if not hasattr(self, '_set_versus_set_wrapper'):
+            self._set_versus_set_wrapper = SetVersusSetVal(proto_message=self._proto_message.SetVersusSet)
+        return self._set_versus_set_wrapper
+    
+    @set_versus_set.setter
+    def set_versus_set(self, value: SetVersusSetVal) -> None:
+        """Set the SetVersusSet field to a wrapper."""
+        self._proto_message.SetVersusSet.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_set_versus_set_wrapper'):
+            self._set_versus_set_wrapper._proto_message.CopyFrom(self._proto_message.SetVersusSet)
+
+
+    # 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/IntervalVal.py

@@ -0,0 +1,102 @@
+"""Generated wrapper for Interval protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .LengthDataVal import LengthDataVal
+
+class IntervalVal:
+    """Simple wrapper for Interval with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.Interval
+
+
+    def __init__(self, distance_interval: Optional[LengthDataVal] = None, distance_move_increment: Optional[LengthDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the Interval wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if distance_interval is not None:
+            self._proto_message.DistanceInterval.CopyFrom(distance_interval.to_proto())
+            self._distance_interval_wrapper = distance_interval
+        if distance_move_increment is not None:
+            self._proto_message.DistanceMoveIncrement.CopyFrom(distance_move_increment.to_proto())
+            self._distance_move_increment_wrapper = distance_move_increment
+
+
+    # Properties
+
+    @property
+    def interval_option(self) -> Any:
+        """Get the IntervalOption field value."""
+        return self._proto_message.IntervalOption
+    
+    @interval_option.setter
+    def interval_option(self, value: Any) -> None:
+        """Set the IntervalOption field value."""
+        self._proto_message.IntervalOption = value
+
+
+    @property
+    def distance_interval(self) -> LengthDataVal:
+        """Get the DistanceInterval field as a wrapper."""
+        if not hasattr(self, '_distance_interval_wrapper'):
+            self._distance_interval_wrapper = LengthDataVal(proto_message=self._proto_message.DistanceInterval)
+        return self._distance_interval_wrapper
+    
+    @distance_interval.setter
+    def distance_interval(self, value: LengthDataVal) -> None:
+        """Set the DistanceInterval field to a wrapper."""
+        self._proto_message.DistanceInterval.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_distance_interval_wrapper'):
+            self._distance_interval_wrapper._proto_message.CopyFrom(self._proto_message.DistanceInterval)
+
+
+    @property
+    def distance_move_increment(self) -> LengthDataVal:
+        """Get the DistanceMoveIncrement field as a wrapper."""
+        if not hasattr(self, '_distance_move_increment_wrapper'):
+            self._distance_move_increment_wrapper = LengthDataVal(proto_message=self._proto_message.DistanceMoveIncrement)
+        return self._distance_move_increment_wrapper
+    
+    @distance_move_increment.setter
+    def distance_move_increment(self, value: LengthDataVal) -> None:
+        """Set the DistanceMoveIncrement field to a wrapper."""
+        self._proto_message.DistanceMoveIncrement.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_distance_move_increment_wrapper'):
+            self._distance_move_increment_wrapper._proto_message.CopyFrom(self._proto_message.DistanceMoveIncrement)
+
+
+    # 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})"