DipsScripting 9.1.0__py3-none-any.whl

dips/RosetteViewRef.py

@@ -0,0 +1,296 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .RosetteViewVal import RosetteViewVal
+from .ArrowToolEntityInfoRef import ArrowToolEntityInfoRef
+from .ArrowToolEntityInfoRef import ArrowToolEntityInfoRef as ArrowToolEntityInfo_RefType
+from .ArrowToolEntityInfoVal import ArrowToolEntityInfoVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+from .EllipseToolEntityInfoRef import EllipseToolEntityInfoRef
+from .EllipseToolEntityInfoRef import EllipseToolEntityInfoRef as EllipseToolEntityInfo_RefType
+from .EllipseToolEntityInfoVal import EllipseToolEntityInfoVal
+from .LineToolEntityInfoRef import LineToolEntityInfoRef
+from .LineToolEntityInfoRef import LineToolEntityInfoRef as LineToolEntityInfo_RefType
+from .LineToolEntityInfoVal import LineToolEntityInfoVal
+from .PlaneEntityVisibilityRef import PlaneEntityVisibilityRef
+from .PolygonToolEntityInfoRef import PolygonToolEntityInfoRef
+from .PolygonToolEntityInfoRef import PolygonToolEntityInfoRef as PolygonToolEntityInfo_RefType
+from .PolygonToolEntityInfoVal import PolygonToolEntityInfoVal
+from .PolylineToolEntityInfoRef import PolylineToolEntityInfoRef
+from .PolylineToolEntityInfoRef import PolylineToolEntityInfoRef as PolylineToolEntityInfo_RefType
+from .PolylineToolEntityInfoVal import PolylineToolEntityInfoVal
+from .RectangleToolEntityInfoRef import RectangleToolEntityInfoRef
+from .RectangleToolEntityInfoRef import RectangleToolEntityInfoRef as RectangleToolEntityInfo_RefType
+from .RectangleToolEntityInfoVal import RectangleToolEntityInfoVal
+from .RosetteSettingsVal import RosetteSettingsVal
+from .StereonetProjectionModeVal import StereonetProjectionModeVal
+from .TextToolEntityInfoRef import TextToolEntityInfoRef
+from .TextToolEntityInfoRef import TextToolEntityInfoRef as TextToolEntityInfo_RefType
+from .TextToolEntityInfoVal import TextToolEntityInfoVal
+from .TrendLineToolEntityInfoRef import TrendLineToolEntityInfoRef
+from .TrendLineToolEntityInfoRef import TrendLineToolEntityInfoRef as TrendLineToolEntityInfo_RefType
+from .TrendLineToolEntityInfoVal import TrendLineToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class RosetteViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_RosetteView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__RosetteServicesStubLocal = DipsAPI_pb2_grpc.RosetteServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> RosetteViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.RosetteView()
+        ret.MergeFromString(bytes.data)
+        return RosetteViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def AddRosetteArrowTool(self,  ArrowToolEntityInfo: ArrowToolEntityInfoVal) -> ArrowToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_ArrowToolEntityInfo(This=self.__modelRef,  Input1=(ArrowToolEntityInfo.to_proto() if hasattr(ArrowToolEntityInfo, 'to_proto') else ArrowToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosetteArrowTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return ArrowToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosetteEllipseTool(self,  EllipseToolEntityInfo: EllipseToolEntityInfoVal) -> EllipseToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_EllipseToolEntityInfo(This=self.__modelRef,  Input1=(EllipseToolEntityInfo.to_proto() if hasattr(EllipseToolEntityInfo, 'to_proto') else EllipseToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosetteEllipseTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return EllipseToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosetteLineTool(self,  LineToolEntityInfo: LineToolEntityInfoVal) -> LineToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_LineToolEntityInfo(This=self.__modelRef,  Input1=(LineToolEntityInfo.to_proto() if hasattr(LineToolEntityInfo, 'to_proto') else LineToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosetteLineTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return LineToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosettePolygonTool(self,  PolygonToolEntityInfo: PolygonToolEntityInfoVal) -> PolygonToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_PolygonToolEntityInfo(This=self.__modelRef,  Input1=(PolygonToolEntityInfo.to_proto() if hasattr(PolygonToolEntityInfo, 'to_proto') else PolygonToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosettePolygonTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return PolygonToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosettePolylineTool(self,  PolylineToolEntityInfo: PolylineToolEntityInfoVal) -> PolylineToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_PolylineToolEntityInfo(This=self.__modelRef,  Input1=(PolylineToolEntityInfo.to_proto() if hasattr(PolylineToolEntityInfo, 'to_proto') else PolylineToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosettePolylineTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return PolylineToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosetteRectangleTool(self,  RectangleToolEntityInfo: RectangleToolEntityInfoVal) -> RectangleToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_RectangleToolEntityInfo(This=self.__modelRef,  Input1=(RectangleToolEntityInfo.to_proto() if hasattr(RectangleToolEntityInfo, 'to_proto') else RectangleToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosetteRectangleTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return RectangleToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosetteTextTool(self,  TextToolEntityInfo: TextToolEntityInfoVal) -> TextToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_TextToolEntityInfo(This=self.__modelRef,  Input1=(TextToolEntityInfo.to_proto() if hasattr(TextToolEntityInfo, 'to_proto') else TextToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosetteTextTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return TextToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def AddRosetteTrendLineTool(self,  TrendLineToolEntityInfo: TrendLineToolEntityInfoVal) -> TrendLineToolEntityInfo_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_TrendLineToolEntityInfo(This=self.__modelRef,  Input1=(TrendLineToolEntityInfo.to_proto() if hasattr(TrendLineToolEntityInfo, 'to_proto') else TrendLineToolEntityInfo))
+        ret = self.__RosetteServicesStubLocal.AddRosetteTrendLineTool(functionParam)
+        
+        if len(ret.Errors) > 0:
+            raise ValueError(ret.Errors[0].ErrorMessage)
+        return TrendLineToolEntityInfo_RefType(self.__channelToConnectOn, ret.Result)
+        
+
+    def CloseRosetteView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.CloseRosetteView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def GetRosetteArrowTools(self) -> List[ArrowToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosetteArrowTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( ArrowToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosetteEllipseTools(self) -> List[EllipseToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosetteEllipseTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( EllipseToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosetteLineTools(self) -> List[LineToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosetteLineTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( LineToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosettePolygonTools(self) -> List[PolygonToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosettePolygonTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( PolygonToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosettePolylineTools(self) -> List[PolylineToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosettePolylineTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( PolylineToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosetteRectangleTools(self) -> List[RectangleToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosetteRectangleTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( RectangleToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosetteTextTools(self) -> List[TextToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosetteTextTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( TextToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetRosetteTrendLineTools(self) -> List[TrendLineToolEntityInfoRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetRosetteTrendLineTools(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( TrendLineToolEntityInfoRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def GetUserPlaneEntityVisibilities(self) -> List[PlaneEntityVisibilityRef]:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView(This=self.__modelRef)
+        ret = self.__RosetteServicesStubLocal.GetUserPlaneEntityVisibilities(functionParam)
+        
+        retList=[]
+        for item in ret.items:
+            retList.append( PlaneEntityVisibilityRef(self.__channelToConnectOn, item) )
+        return retList
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__RosetteServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+    def SetArrowToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetArrowToolEntityGroupVisibility(functionParam)
+        
+
+    def SetEllipseToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetEllipseToolEntityGroupVisibility(functionParam)
+        
+
+    def SetLineToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetLineToolEntityGroupVisibility(functionParam)
+        
+
+    def SetPolygonToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetPolygonToolEntityGroupVisibility(functionParam)
+        
+
+    def SetPolylineToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetPolylineToolEntityGroupVisibility(functionParam)
+        
+
+    def SetProjectionMode(self,  StereonetProjectionMode: StereonetProjectionModeVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_StereonetProjectionMode(This=self.__modelRef,  Input1=(StereonetProjectionMode.to_proto() if hasattr(StereonetProjectionMode, 'to_proto') else StereonetProjectionMode))
+        ret = self.__RosetteServicesStubLocal.SetProjectionMode(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+    def SetRectangleToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetRectangleToolEntityGroupVisibility(functionParam)
+        
+
+    def SetRosetteSettings(self,  RosetteSettings: RosetteSettingsVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_RosetteSettings(This=self.__modelRef,  Input1=(RosetteSettings.to_proto() if hasattr(RosetteSettings, 'to_proto') else RosetteSettings))
+        ret = self.__RosetteServicesStubLocal.SetRosetteSettings(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+    def SetTextToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetTextToolEntityGroupVisibility(functionParam)
+        
+
+    def SetToolsEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetToolsEntityGroupVisibility(functionParam)
+        
+
+    def SetTrendLineToolEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetTrendLineToolEntityGroupVisibility(functionParam)
+        
+
+    def SetUserPlaneEntityGroupVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_RosetteView_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__RosetteServicesStubLocal.SetUserPlaneEntityGroupVisibility(functionParam)
+        
+
+ 

dips/RosetteViewVal.py

@@ -0,0 +1,177 @@
+"""Generated wrapper for RosetteView protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AnnotativeTools2DVal import AnnotativeTools2DVal
+from .PlaneEntityVisibilityVal import PlaneEntityVisibilityVal
+from .RosettePresetOptionsVal import RosettePresetOptionsVal
+from .RosetteSettingsVal import RosetteSettingsVal
+from .StereonetProjectionModeVal import StereonetProjectionModeVal
+from .DataFilterRef import DataFilterRef
+
+class RosetteViewVal:
+    """Simple wrapper for RosetteView with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.RosetteView
+
+
+    def __init__(self, rosette_settings: Optional[RosetteSettingsVal] = None, projection_mode: Optional[StereonetProjectionModeVal] = None, preset_options: Optional[RosettePresetOptionsVal] = None, annotative_tools: Optional[AnnotativeTools2DVal] = None, active_filter: Optional[DataFilterRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the RosetteView 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 rosette_settings is not None:
+            self._proto_message.RosetteSettings.CopyFrom(rosette_settings.to_proto())
+            self._rosette_settings_wrapper = rosette_settings
+        if projection_mode is not None:
+            self._proto_message.ProjectionMode.CopyFrom(projection_mode.to_proto())
+            self._projection_mode_wrapper = projection_mode
+        if preset_options is not None:
+            self._proto_message.PresetOptions.CopyFrom(preset_options.to_proto())
+            self._preset_options_wrapper = preset_options
+        if annotative_tools is not None:
+            self._proto_message.AnnotativeTools.CopyFrom(annotative_tools.to_proto())
+            self._annotative_tools_wrapper = annotative_tools
+        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 rosette_settings(self) -> RosetteSettingsVal:
+        """Get the RosetteSettings field as a wrapper."""
+        if not hasattr(self, '_rosette_settings_wrapper'):
+            self._rosette_settings_wrapper = RosetteSettingsVal(proto_message=self._proto_message.RosetteSettings)
+        return self._rosette_settings_wrapper
+    
+    @rosette_settings.setter
+    def rosette_settings(self, value: RosetteSettingsVal) -> None:
+        """Set the RosetteSettings field to a wrapper."""
+        self._proto_message.RosetteSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_rosette_settings_wrapper'):
+            self._rosette_settings_wrapper._proto_message.CopyFrom(self._proto_message.RosetteSettings)
+
+
+    @property
+    def projection_mode(self) -> StereonetProjectionModeVal:
+        """Get the ProjectionMode field as a wrapper."""
+        if not hasattr(self, '_projection_mode_wrapper'):
+            self._projection_mode_wrapper = StereonetProjectionModeVal(proto_message=self._proto_message.ProjectionMode)
+        return self._projection_mode_wrapper
+    
+    @projection_mode.setter
+    def projection_mode(self, value: StereonetProjectionModeVal) -> None:
+        """Set the ProjectionMode field to a wrapper."""
+        self._proto_message.ProjectionMode.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_projection_mode_wrapper'):
+            self._projection_mode_wrapper._proto_message.CopyFrom(self._proto_message.ProjectionMode)
+
+
+    @property
+    def preset_options(self) -> RosettePresetOptionsVal:
+        """Get the PresetOptions field as a wrapper."""
+        if not hasattr(self, '_preset_options_wrapper'):
+            self._preset_options_wrapper = RosettePresetOptionsVal(proto_message=self._proto_message.PresetOptions)
+        return self._preset_options_wrapper
+    
+    @preset_options.setter
+    def preset_options(self, value: RosettePresetOptionsVal) -> None:
+        """Set the PresetOptions field to a wrapper."""
+        self._proto_message.PresetOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_preset_options_wrapper'):
+            self._preset_options_wrapper._proto_message.CopyFrom(self._proto_message.PresetOptions)
+
+
+    @property
+    def user_plane_entity_visibilities(self) -> List[PlaneEntityVisibilityVal]:
+        """Get the UserPlaneEntityVisibilities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.UserPlaneEntityVisibilities, PlaneEntityVisibilityVal)
+    
+    @user_plane_entity_visibilities.setter
+    def user_plane_entity_visibilities(self, value: List[PlaneEntityVisibilityVal]) -> None:
+        """Set the UserPlaneEntityVisibilities field to a list of wrappers."""
+        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.UserPlaneEntityVisibilities[:] = []
+        for item in value:
+            self._proto_message.UserPlaneEntityVisibilities.append(item.to_proto())
+
+
+    @property
+    def annotative_tools(self) -> AnnotativeTools2DVal:
+        """Get the AnnotativeTools field as a wrapper."""
+        if not hasattr(self, '_annotative_tools_wrapper'):
+            self._annotative_tools_wrapper = AnnotativeTools2DVal(proto_message=self._proto_message.AnnotativeTools)
+        return self._annotative_tools_wrapper
+    
+    @annotative_tools.setter
+    def annotative_tools(self, value: AnnotativeTools2DVal) -> None:
+        """Set the AnnotativeTools field to a wrapper."""
+        self._proto_message.AnnotativeTools.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_annotative_tools_wrapper'):
+            self._annotative_tools_wrapper._proto_message.CopyFrom(self._proto_message.AnnotativeTools)
+
+
+    @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/ScatterChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .ScatterChartViewVal import ScatterChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class ScatterChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_ScatterChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__ScatterChartServicesStubLocal = DipsAPI_pb2_grpc.ScatterChartServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> ScatterChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.ScatterChartView()
+        ret.MergeFromString(bytes.data)
+        return ScatterChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseScatterChartView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ScatterChartView(This=self.__modelRef)
+        ret = self.__ScatterChartServicesStubLocal.CloseScatterChartView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ScatterChartView(This=self.__modelRef)
+        ret = self.__ScatterChartServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ScatterChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__ScatterChartServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+ 

dips/ScatterChartViewVal.py

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