DipsScripting 9.1.0__py3-none-any.whl

dips/SymbolDisplaySettingVal.py

@@ -0,0 +1,124 @@
+"""Generated wrapper for SymbolDisplaySetting protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+
+class SymbolDisplaySettingVal:
+    """Simple wrapper for SymbolDisplaySetting with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SymbolDisplaySetting
+
+
+    def __init__(self, border_color: Optional[ColorSurrogateVal] = None, fill_color: Optional[ColorSurrogateVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the SymbolDisplaySetting wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if border_color is not None:
+            self._proto_message.BorderColor.CopyFrom(border_color.to_proto())
+            self._border_color_wrapper = border_color
+        if fill_color is not None:
+            self._proto_message.FillColor.CopyFrom(fill_color.to_proto())
+            self._fill_color_wrapper = fill_color
+
+
+    # Properties
+
+    @property
+    def symbol_style(self) -> Any:
+        """Get the SymbolStyle field value."""
+        return self._proto_message.SymbolStyle
+    
+    @symbol_style.setter
+    def symbol_style(self, value: Any) -> None:
+        """Set the SymbolStyle field value."""
+        self._proto_message.SymbolStyle = value
+
+
+    @property
+    def border_color(self) -> ColorSurrogateVal:
+        """Get the BorderColor field as a wrapper."""
+        if not hasattr(self, '_border_color_wrapper'):
+            self._border_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.BorderColor)
+        return self._border_color_wrapper
+    
+    @border_color.setter
+    def border_color(self, value: ColorSurrogateVal) -> None:
+        """Set the BorderColor field to a wrapper."""
+        self._proto_message.BorderColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_border_color_wrapper'):
+            self._border_color_wrapper._proto_message.CopyFrom(self._proto_message.BorderColor)
+
+
+    @property
+    def is_fill(self) -> bool:
+        """Get the IsFill field value."""
+        return self._proto_message.IsFill
+    
+    @is_fill.setter
+    def is_fill(self, value: bool) -> None:
+        """Set the IsFill field value."""
+        self._proto_message.IsFill = value
+
+
+    @property
+    def fill_color(self) -> ColorSurrogateVal:
+        """Get the FillColor field as a wrapper."""
+        if not hasattr(self, '_fill_color_wrapper'):
+            self._fill_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.FillColor)
+        return self._fill_color_wrapper
+    
+    @fill_color.setter
+    def fill_color(self, value: ColorSurrogateVal) -> None:
+        """Set the FillColor field to a wrapper."""
+        self._proto_message.FillColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_fill_color_wrapper'):
+            self._fill_color_wrapper._proto_message.CopyFrom(self._proto_message.FillColor)
+
+
+    @property
+    def symbol_scale(self) -> float:
+        """Get the SymbolScale field value."""
+        return self._proto_message.SymbolScale
+    
+    @symbol_scale.setter
+    def symbol_scale(self, value: float) -> None:
+        """Set the SymbolScale field value."""
+        self._proto_message.SymbolScale = 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/SymbolicSettingsVal.py

@@ -0,0 +1,89 @@
+"""Generated wrapper for SymbolicSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .QualitativeQuantitativeAnalysisSettingsVal import QualitativeQuantitativeAnalysisSettingsVal
+from .SymbolDisplaySettingVal import SymbolDisplaySettingVal
+
+class SymbolicSettingsVal:
+    """Simple wrapper for SymbolicSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SymbolicSettings
+
+
+    def __init__(self, qualitative_quantitative_analysis_settings: Optional[QualitativeQuantitativeAnalysisSettingsVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the SymbolicSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        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
+
+
+    # Properties
+
+    @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 legend_symbols(self) -> List[SymbolDisplaySettingVal]:
+        """Get the LegendSymbols field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.LegendSymbols, SymbolDisplaySettingVal)
+    
+    @legend_symbols.setter
+    def legend_symbols(self, value: List[SymbolDisplaySettingVal]) -> None:
+        """Set the LegendSymbols 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.LegendSymbols[:] = []
+        for item in value:
+            self._proto_message.LegendSymbols.append(item.to_proto())
+
+
+    # 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/TextFormatVal.py

@@ -0,0 +1,105 @@
+"""Generated wrapper for TextFormat protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+
+class TextFormatVal:
+    """Simple wrapper for TextFormat with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.TextFormat
+
+
+    def __init__(self, text_color: Optional[ColorSurrogateVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the TextFormat wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if text_color is not None:
+            self._proto_message.TextColor.CopyFrom(text_color.to_proto())
+            self._text_color_wrapper = text_color
+
+
+    # Properties
+
+    @property
+    def text_horizontal_alignment(self) -> Any:
+        """Get the TextHorizontalAlignment field value."""
+        return self._proto_message.TextHorizontalAlignment
+    
+    @text_horizontal_alignment.setter
+    def text_horizontal_alignment(self, value: Any) -> None:
+        """Set the TextHorizontalAlignment field value."""
+        self._proto_message.TextHorizontalAlignment = value
+
+
+    @property
+    def text_color(self) -> ColorSurrogateVal:
+        """Get the TextColor field as a wrapper."""
+        if not hasattr(self, '_text_color_wrapper'):
+            self._text_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.TextColor)
+        return self._text_color_wrapper
+    
+    @text_color.setter
+    def text_color(self, value: ColorSurrogateVal) -> None:
+        """Set the TextColor field to a wrapper."""
+        self._proto_message.TextColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_text_color_wrapper'):
+            self._text_color_wrapper._proto_message.CopyFrom(self._proto_message.TextColor)
+
+
+    @property
+    def font_name(self) -> str:
+        """Get the FontName field value."""
+        return self._proto_message.FontName
+    
+    @font_name.setter
+    def font_name(self, value: str) -> None:
+        """Set the FontName field value."""
+        self._proto_message.FontName = value
+
+
+    @property
+    def font_size(self) -> int:
+        """Get the FontSize field value."""
+        return self._proto_message.FontSize
+    
+    @font_size.setter
+    def font_size(self, value: int) -> None:
+        """Set the FontSize field value."""
+        self._proto_message.FontSize = 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/TextToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .TextToolEntityInfoVal import TextToolEntityInfoVal
+from .TextToolEntityInfoVal import TextToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class TextToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_TextToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> TextToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.TextToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return TextToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveTextTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TextToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveTextTool(functionParam)
+        
+
+    def SetTextToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TextToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetTextToolVisibility(functionParam)
+        
+
+    def UpdateTextTool(self,  TextToolEntityInfo: TextToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TextToolEntityInfo_TextToolEntityInfo(This=self.__modelRef,  Input1=(TextToolEntityInfo.to_proto() if hasattr(TextToolEntityInfo, 'to_proto') else TextToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateTextTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/TextToolEntityInfoVal.py

@@ -0,0 +1,176 @@
+"""Generated wrapper for TextToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AnchorPointVal import AnchorPointVal
+from .FillFormatVal import FillFormatVal
+from .LineFormatVal import LineFormatVal
+from .TextFormatVal import TextFormatVal
+
+class TextToolEntityInfoVal:
+    """Simple wrapper for TextToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.TextToolEntityInfo
+
+
+    def __init__(self, anchor_point: Optional[AnchorPointVal] = None, line_format: Optional[LineFormatVal] = None, fill_format: Optional[FillFormatVal] = None, text_format: Optional[TextFormatVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the TextToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if anchor_point is not None:
+            self._proto_message.AnchorPoint.CopyFrom(anchor_point.to_proto())
+            self._anchor_point_wrapper = anchor_point
+        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 text_format is not None:
+            self._proto_message.TextFormat.CopyFrom(text_format.to_proto())
+            self._text_format_wrapper = text_format
+
+
+    # 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 anchor_point(self) -> AnchorPointVal:
+        """Get the AnchorPoint field as a wrapper."""
+        if not hasattr(self, '_anchor_point_wrapper'):
+            self._anchor_point_wrapper = AnchorPointVal(proto_message=self._proto_message.AnchorPoint)
+        return self._anchor_point_wrapper
+    
+    @anchor_point.setter
+    def anchor_point(self, value: AnchorPointVal) -> None:
+        """Set the AnchorPoint field to a wrapper."""
+        self._proto_message.AnchorPoint.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_anchor_point_wrapper'):
+            self._anchor_point_wrapper._proto_message.CopyFrom(self._proto_message.AnchorPoint)
+
+
+    @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 text_format(self) -> TextFormatVal:
+        """Get the TextFormat field as a wrapper."""
+        if not hasattr(self, '_text_format_wrapper'):
+            self._text_format_wrapper = TextFormatVal(proto_message=self._proto_message.TextFormat)
+        return self._text_format_wrapper
+    
+    @text_format.setter
+    def text_format(self, value: TextFormatVal) -> None:
+        """Set the TextFormat field to a wrapper."""
+        self._proto_message.TextFormat.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_text_format_wrapper'):
+            self._text_format_wrapper._proto_message.CopyFrom(self._proto_message.TextFormat)
+
+
+    @property
+    def text(self) -> str:
+        """Get the Text field value."""
+        return self._proto_message.Text
+    
+    @text.setter
+    def text(self, value: str) -> None:
+        """Set the Text field value."""
+        self._proto_message.Text = value
+
+
+    @property
+    def autogenerated_text(self) -> str:
+        """Get the AutogeneratedText field value."""
+        return self._proto_message.AutogeneratedText
+    
+    @autogenerated_text.setter
+    def autogenerated_text(self, value: str) -> None:
+        """Set the AutogeneratedText field value."""
+        self._proto_message.AutogeneratedText = 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/TraverseEntityOptionsVal.py

@@ -0,0 +1,84 @@
+"""Generated wrapper for TraverseEntityOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class TraverseEntityOptionsVal:
+    """Simple wrapper for TraverseEntityOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.TraverseEntityOptions
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the TraverseEntityOptions 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 show_all_points(self) -> bool:
+        """Get the ShowAllPoints field value."""
+        return self._proto_message.ShowAllPoints
+    
+    @show_all_points.setter
+    def show_all_points(self, value: bool) -> None:
+        """Set the ShowAllPoints field value."""
+        self._proto_message.ShowAllPoints = value
+
+
+    @property
+    def show_label(self) -> bool:
+        """Get the ShowLabel field value."""
+        return self._proto_message.ShowLabel
+    
+    @show_label.setter
+    def show_label(self, value: bool) -> None:
+        """Set the ShowLabel field value."""
+        self._proto_message.ShowLabel = value
+
+
+    @property
+    def show_blind_zone(self) -> bool:
+        """Get the ShowBlindZone field value."""
+        return self._proto_message.ShowBlindZone
+    
+    @show_blind_zone.setter
+    def show_blind_zone(self, value: bool) -> None:
+        """Set the ShowBlindZone field value."""
+        self._proto_message.ShowBlindZone = 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/TraverseEntityVisibilityRef.py

@@ -0,0 +1,38 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .TraverseEntityVisibilityVal import TraverseEntityVisibilityVal
+from .TraverseEntityVisibilityVal import TraverseEntityVisibilityVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class TraverseEntityVisibilityRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_TraverseEntityVisibility):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> TraverseEntityVisibilityVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.TraverseEntityVisibility()
+        ret.MergeFromString(bytes.data)
+        return TraverseEntityVisibilityVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def SetTraverseEntityOptions(self,  TraverseEntityVisibility: TraverseEntityVisibilityVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TraverseEntityVisibility_TraverseEntityVisibility(This=self.__modelRef,  Input1=(TraverseEntityVisibility.to_proto() if hasattr(TraverseEntityVisibility, 'to_proto') else TraverseEntityVisibility))
+        ret = self.__EntityServicesStubLocal.SetTraverseEntityOptions(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+    def SetTraverseEntityVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_TraverseEntityVisibility_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetTraverseEntityVisibility(functionParam)
+        
+
+