DipsScripting 9.1.0__py3-none-any.whl

dips/RectangleToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .RectangleToolEntityInfoVal import RectangleToolEntityInfoVal
+from .RectangleToolEntityInfoVal import RectangleToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class RectangleToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_RectangleToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> RectangleToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.RectangleToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return RectangleToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveRectangleTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RectangleToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveRectangleTool(functionParam)
+        
+
+    def SetRectangleToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RectangleToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetRectangleToolVisibility(functionParam)
+        
+
+    def UpdateRectangleTool(self,  RectangleToolEntityInfo: RectangleToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RectangleToolEntityInfo_RectangleToolEntityInfo(This=self.__modelRef,  Input1=(RectangleToolEntityInfo.to_proto() if hasattr(RectangleToolEntityInfo, 'to_proto') else RectangleToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateRectangleTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/RectangleToolEntityInfoVal.py

@@ -0,0 +1,153 @@
+"""Generated wrapper for RectangleToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .FillFormatVal import FillFormatVal
+from .LineFormatVal import LineFormatVal
+from .Vector2DVal import Vector2DVal
+
+class RectangleToolEntityInfoVal:
+    """Simple wrapper for RectangleToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.RectangleToolEntityInfo
+
+
+    def __init__(self, line_format: Optional[LineFormatVal] = None, fill_format: Optional[FillFormatVal] = None, first_corner: Optional[Vector2DVal] = None, second_corner: Optional[Vector2DVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the RectangleToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if line_format is not None:
+            self._proto_message.LineFormat.CopyFrom(line_format.to_proto())
+            self._line_format_wrapper = line_format
+        if fill_format is not None:
+            self._proto_message.FillFormat.CopyFrom(fill_format.to_proto())
+            self._fill_format_wrapper = fill_format
+        if first_corner is not None:
+            self._proto_message.FirstCorner.CopyFrom(first_corner.to_proto())
+            self._first_corner_wrapper = first_corner
+        if second_corner is not None:
+            self._proto_message.SecondCorner.CopyFrom(second_corner.to_proto())
+            self._second_corner_wrapper = second_corner
+
+
+    # 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 name(self) -> str:
+        """Get the Name field value."""
+        return self._proto_message.Name
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        """Set the Name field value."""
+        self._proto_message.Name = value
+
+
+    @property
+    def line_format(self) -> LineFormatVal:
+        """Get the LineFormat field as a wrapper."""
+        if not hasattr(self, '_line_format_wrapper'):
+            self._line_format_wrapper = LineFormatVal(proto_message=self._proto_message.LineFormat)
+        return self._line_format_wrapper
+    
+    @line_format.setter
+    def line_format(self, value: LineFormatVal) -> None:
+        """Set the LineFormat field to a wrapper."""
+        self._proto_message.LineFormat.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_line_format_wrapper'):
+            self._line_format_wrapper._proto_message.CopyFrom(self._proto_message.LineFormat)
+
+
+    @property
+    def fill_format(self) -> FillFormatVal:
+        """Get the FillFormat field as a wrapper."""
+        if not hasattr(self, '_fill_format_wrapper'):
+            self._fill_format_wrapper = FillFormatVal(proto_message=self._proto_message.FillFormat)
+        return self._fill_format_wrapper
+    
+    @fill_format.setter
+    def fill_format(self, value: FillFormatVal) -> None:
+        """Set the FillFormat field to a wrapper."""
+        self._proto_message.FillFormat.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_fill_format_wrapper'):
+            self._fill_format_wrapper._proto_message.CopyFrom(self._proto_message.FillFormat)
+
+
+    @property
+    def first_corner(self) -> Vector2DVal:
+        """Get the FirstCorner field as a wrapper."""
+        if not hasattr(self, '_first_corner_wrapper'):
+            self._first_corner_wrapper = Vector2DVal(proto_message=self._proto_message.FirstCorner)
+        return self._first_corner_wrapper
+    
+    @first_corner.setter
+    def first_corner(self, value: Vector2DVal) -> None:
+        """Set the FirstCorner field to a wrapper."""
+        self._proto_message.FirstCorner.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_first_corner_wrapper'):
+            self._first_corner_wrapper._proto_message.CopyFrom(self._proto_message.FirstCorner)
+
+
+    @property
+    def second_corner(self) -> Vector2DVal:
+        """Get the SecondCorner field as a wrapper."""
+        if not hasattr(self, '_second_corner_wrapper'):
+            self._second_corner_wrapper = Vector2DVal(proto_message=self._proto_message.SecondCorner)
+        return self._second_corner_wrapper
+    
+    @second_corner.setter
+    def second_corner(self, value: Vector2DVal) -> None:
+        """Set the SecondCorner field to a wrapper."""
+        self._proto_message.SecondCorner.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_second_corner_wrapper'):
+            self._second_corner_wrapper._proto_message.CopyFrom(self._proto_message.SecondCorner)
+
+
+    # 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/ReportingConventionResultVal.py

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

@@ -0,0 +1,227 @@
+"""Generated wrapper for RosettePresetOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class RosettePresetOptionsVal:
+    """Simple wrapper for RosettePresetOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.RosettePresetOptions
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the RosettePresetOptions 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 user_plane_entity_group_visibility(self) -> bool:
+        """Get the UserPlaneEntityGroupVisibility field value."""
+        return self._proto_message.UserPlaneEntityGroupVisibility
+    
+    @user_plane_entity_group_visibility.setter
+    def user_plane_entity_group_visibility(self, value: bool) -> None:
+        """Set the UserPlaneEntityGroupVisibility field value."""
+        self._proto_message.UserPlaneEntityGroupVisibility = value
+
+
+    @property
+    def tools_entity_group_visibility(self) -> bool:
+        """Get the ToolsEntityGroupVisibility field value."""
+        return self._proto_message.ToolsEntityGroupVisibility
+    
+    @tools_entity_group_visibility.setter
+    def tools_entity_group_visibility(self, value: bool) -> None:
+        """Set the ToolsEntityGroupVisibility field value."""
+        self._proto_message.ToolsEntityGroupVisibility = value
+
+
+    @property
+    def text_tool_entity_group_visibility(self) -> bool:
+        """Get the TextToolEntityGroupVisibility field value."""
+        return self._proto_message.TextToolEntityGroupVisibility
+    
+    @text_tool_entity_group_visibility.setter
+    def text_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the TextToolEntityGroupVisibility field value."""
+        self._proto_message.TextToolEntityGroupVisibility = value
+
+
+    @property
+    def arrow_tool_entity_group_visibility(self) -> bool:
+        """Get the ArrowToolEntityGroupVisibility field value."""
+        return self._proto_message.ArrowToolEntityGroupVisibility
+    
+    @arrow_tool_entity_group_visibility.setter
+    def arrow_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the ArrowToolEntityGroupVisibility field value."""
+        self._proto_message.ArrowToolEntityGroupVisibility = value
+
+
+    @property
+    def line_tool_entity_group_visibility(self) -> bool:
+        """Get the LineToolEntityGroupVisibility field value."""
+        return self._proto_message.LineToolEntityGroupVisibility
+    
+    @line_tool_entity_group_visibility.setter
+    def line_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the LineToolEntityGroupVisibility field value."""
+        self._proto_message.LineToolEntityGroupVisibility = value
+
+
+    @property
+    def polyline_tool_entity_group_visibility(self) -> bool:
+        """Get the PolylineToolEntityGroupVisibility field value."""
+        return self._proto_message.PolylineToolEntityGroupVisibility
+    
+    @polyline_tool_entity_group_visibility.setter
+    def polyline_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the PolylineToolEntityGroupVisibility field value."""
+        self._proto_message.PolylineToolEntityGroupVisibility = value
+
+
+    @property
+    def polygon_tool_entity_group_visibility(self) -> bool:
+        """Get the PolygonToolEntityGroupVisibility field value."""
+        return self._proto_message.PolygonToolEntityGroupVisibility
+    
+    @polygon_tool_entity_group_visibility.setter
+    def polygon_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the PolygonToolEntityGroupVisibility field value."""
+        self._proto_message.PolygonToolEntityGroupVisibility = value
+
+
+    @property
+    def rectangle_tool_entity_group_visibility(self) -> bool:
+        """Get the RectangleToolEntityGroupVisibility field value."""
+        return self._proto_message.RectangleToolEntityGroupVisibility
+    
+    @rectangle_tool_entity_group_visibility.setter
+    def rectangle_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the RectangleToolEntityGroupVisibility field value."""
+        self._proto_message.RectangleToolEntityGroupVisibility = value
+
+
+    @property
+    def ellipse_tool_entity_group_visibility(self) -> bool:
+        """Get the EllipseToolEntityGroupVisibility field value."""
+        return self._proto_message.EllipseToolEntityGroupVisibility
+    
+    @ellipse_tool_entity_group_visibility.setter
+    def ellipse_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the EllipseToolEntityGroupVisibility field value."""
+        self._proto_message.EllipseToolEntityGroupVisibility = value
+
+
+    @property
+    def cone_tool_entity_group_visibility(self) -> bool:
+        """Get the ConeToolEntityGroupVisibility field value."""
+        return self._proto_message.ConeToolEntityGroupVisibility
+    
+    @cone_tool_entity_group_visibility.setter
+    def cone_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the ConeToolEntityGroupVisibility field value."""
+        self._proto_message.ConeToolEntityGroupVisibility = value
+
+
+    @property
+    def trend_line_tool_entity_group_visibility(self) -> bool:
+        """Get the TrendLineToolEntityGroupVisibility field value."""
+        return self._proto_message.TrendLineToolEntityGroupVisibility
+    
+    @trend_line_tool_entity_group_visibility.setter
+    def trend_line_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the TrendLineToolEntityGroupVisibility field value."""
+        self._proto_message.TrendLineToolEntityGroupVisibility = value
+
+
+    @property
+    def pitch_grid_tool_entity_group_visibility(self) -> bool:
+        """Get the PitchGridToolEntityGroupVisibility field value."""
+        return self._proto_message.PitchGridToolEntityGroupVisibility
+    
+    @pitch_grid_tool_entity_group_visibility.setter
+    def pitch_grid_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the PitchGridToolEntityGroupVisibility field value."""
+        self._proto_message.PitchGridToolEntityGroupVisibility = value
+
+
+    @property
+    def measure_angle_tool_entity_group_visibility(self) -> bool:
+        """Get the MeasureAngleToolEntityGroupVisibility field value."""
+        return self._proto_message.MeasureAngleToolEntityGroupVisibility
+    
+    @measure_angle_tool_entity_group_visibility.setter
+    def measure_angle_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the MeasureAngleToolEntityGroupVisibility field value."""
+        self._proto_message.MeasureAngleToolEntityGroupVisibility = value
+
+
+    @property
+    def line_intersection_calculator_tool_entity_group_visibility(self) -> bool:
+        """Get the LineIntersectionCalculatorToolEntityGroupVisibility field value."""
+        return self._proto_message.LineIntersectionCalculatorToolEntityGroupVisibility
+    
+    @line_intersection_calculator_tool_entity_group_visibility.setter
+    def line_intersection_calculator_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the LineIntersectionCalculatorToolEntityGroupVisibility field value."""
+        self._proto_message.LineIntersectionCalculatorToolEntityGroupVisibility = value
+
+
+    @property
+    def plane_intersection_calculator_tool_entity_group_visibility(self) -> bool:
+        """Get the PlaneIntersectionCalculatorToolEntityGroupVisibility field value."""
+        return self._proto_message.PlaneIntersectionCalculatorToolEntityGroupVisibility
+    
+    @plane_intersection_calculator_tool_entity_group_visibility.setter
+    def plane_intersection_calculator_tool_entity_group_visibility(self, value: bool) -> None:
+        """Set the PlaneIntersectionCalculatorToolEntityGroupVisibility field value."""
+        self._proto_message.PlaneIntersectionCalculatorToolEntityGroupVisibility = value
+
+
+    @property
+    def show_legend(self) -> bool:
+        """Get the ShowLegend field value."""
+        return self._proto_message.ShowLegend
+    
+    @show_legend.setter
+    def show_legend(self, value: bool) -> None:
+        """Set the ShowLegend field value."""
+        self._proto_message.ShowLegend = 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/RosetteSettingsVal.py

@@ -0,0 +1,174 @@
+"""Generated wrapper for RosetteSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+from .TrendPlungeVal import TrendPlungeVal
+
+class RosetteSettingsVal:
+    """Simple wrapper for RosetteSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.RosetteSettings
+
+
+    def __init__(self, sight_line_orientation: Optional[TrendPlungeVal] = None, min_angle: Optional[AngleDataVal] = None, max_angle: Optional[AngleDataVal] = None, start_bin_strike: Optional[AngleDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the RosetteSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if sight_line_orientation is not None:
+            self._proto_message.SightLineOrientation.CopyFrom(sight_line_orientation.to_proto())
+            self._sight_line_orientation_wrapper = sight_line_orientation
+        if min_angle is not None:
+            self._proto_message.MinAngle.CopyFrom(min_angle.to_proto())
+            self._min_angle_wrapper = min_angle
+        if max_angle is not None:
+            self._proto_message.MaxAngle.CopyFrom(max_angle.to_proto())
+            self._max_angle_wrapper = max_angle
+        if start_bin_strike is not None:
+            self._proto_message.StartBinStrike.CopyFrom(start_bin_strike.to_proto())
+            self._start_bin_strike_wrapper = start_bin_strike
+
+
+    # Properties
+
+    @property
+    def sight_line_orientation(self) -> TrendPlungeVal:
+        """Get the SightLineOrientation field as a wrapper."""
+        if not hasattr(self, '_sight_line_orientation_wrapper'):
+            self._sight_line_orientation_wrapper = TrendPlungeVal(proto_message=self._proto_message.SightLineOrientation)
+        return self._sight_line_orientation_wrapper
+    
+    @sight_line_orientation.setter
+    def sight_line_orientation(self, value: TrendPlungeVal) -> None:
+        """Set the SightLineOrientation field to a wrapper."""
+        self._proto_message.SightLineOrientation.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_sight_line_orientation_wrapper'):
+            self._sight_line_orientation_wrapper._proto_message.CopyFrom(self._proto_message.SightLineOrientation)
+
+
+    @property
+    def min_angle(self) -> AngleDataVal:
+        """Get the MinAngle field as a wrapper."""
+        if not hasattr(self, '_min_angle_wrapper'):
+            self._min_angle_wrapper = AngleDataVal(proto_message=self._proto_message.MinAngle)
+        return self._min_angle_wrapper
+    
+    @min_angle.setter
+    def min_angle(self, value: AngleDataVal) -> None:
+        """Set the MinAngle field to a wrapper."""
+        self._proto_message.MinAngle.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_min_angle_wrapper'):
+            self._min_angle_wrapper._proto_message.CopyFrom(self._proto_message.MinAngle)
+
+
+    @property
+    def max_angle(self) -> AngleDataVal:
+        """Get the MaxAngle field as a wrapper."""
+        if not hasattr(self, '_max_angle_wrapper'):
+            self._max_angle_wrapper = AngleDataVal(proto_message=self._proto_message.MaxAngle)
+        return self._max_angle_wrapper
+    
+    @max_angle.setter
+    def max_angle(self, value: AngleDataVal) -> None:
+        """Set the MaxAngle field to a wrapper."""
+        self._proto_message.MaxAngle.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_max_angle_wrapper'):
+            self._max_angle_wrapper._proto_message.CopyFrom(self._proto_message.MaxAngle)
+
+
+    @property
+    def start_bin_strike(self) -> AngleDataVal:
+        """Get the StartBinStrike field as a wrapper."""
+        if not hasattr(self, '_start_bin_strike_wrapper'):
+            self._start_bin_strike_wrapper = AngleDataVal(proto_message=self._proto_message.StartBinStrike)
+        return self._start_bin_strike_wrapper
+    
+    @start_bin_strike.setter
+    def start_bin_strike(self, value: AngleDataVal) -> None:
+        """Set the StartBinStrike field to a wrapper."""
+        self._proto_message.StartBinStrike.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_start_bin_strike_wrapper'):
+            self._start_bin_strike_wrapper._proto_message.CopyFrom(self._proto_message.StartBinStrike)
+
+
+    @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 custom_scaling(self) -> bool:
+        """Get the CustomScaling field value."""
+        return self._proto_message.CustomScaling
+    
+    @custom_scaling.setter
+    def custom_scaling(self, value: bool) -> None:
+        """Set the CustomScaling field value."""
+        self._proto_message.CustomScaling = value
+
+
+    @property
+    def num_planes_per_circle_increment(self) -> int:
+        """Get the NumPlanesPerCircleIncrement field value."""
+        return self._proto_message.NumPlanesPerCircleIncrement
+    
+    @num_planes_per_circle_increment.setter
+    def num_planes_per_circle_increment(self, value: int) -> None:
+        """Set the NumPlanesPerCircleIncrement field value."""
+        self._proto_message.NumPlanesPerCircleIncrement = 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})"