DipsScripting 9.1.0__py3-none-any.whl

dips/DipsApp.py

@@ -0,0 +1,81 @@
+import grpc
+from .DipsAPI_pb2_grpc import AppServiceStub
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+from .ApplicationManager import ApplicationManager
+from .ProjStubRef import ProjStubRef
+from logging import Logger
+import winreg
+
+class DipsApp:
+    @staticmethod
+    def AttachToExisting(port):
+        ret = DipsApp(port)
+        return ret
+    
+    @staticmethod
+    def LaunchApp(port, overridePathToExecutable : str = None, timeout : float = 120, headless : bool = False, fileToOpen : str = None):
+        DipsApp.startApplication(port, overridePathToExecutable, timeout, headless, fileToOpen)
+        ret = DipsApp(port)
+        return ret
+
+    def __init__(self, port):
+        channel = grpc.insecure_channel('localhost:{port}'.format(port = port))
+        self.__stub = AppServiceStub(channel)
+        self.__channel = channel
+
+    @staticmethod
+    def startApplication(port : int, overridePathToExecutable : str = None, timeout : float = 120, headless : bool = False, fileToOpen : str = None) -> None:
+        """Opens the most recently installed RS2 application. Starts the python server and binds it to the given port.
+
+        Args:
+            port (int): the port to bind the python server to. Use this same port when initializing RS2Modeler
+            overridePathToExecutable (str, optional): full path to the desired executable to be opened. If not provided, the latest installation of rs2 is used
+            timeout (float, optional): the maximum amount of time to wait for the application and server to start.
+        
+        Raises:
+            ValueError: Port range must be between 49152 and 65535, otherwise ValueError is raised
+            TimeoutError: if timeout is provided, raises TimeoutError if not able to connect to the server within that time.
+        """
+        appManager = ApplicationManager()
+        if overridePathToExecutable is None:
+            executablePath = DipsApp._getApplicationPath()
+        else:
+            executablePath = overridePathToExecutable
+        
+
+        appManager.startApplication(executablePath, port, DipsApp._isServerRunning, Logger("Test"), timeout, headless, fileToOpen)
+
+    @staticmethod
+    def _getApplicationPath() -> str:
+        registry = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+        key = winreg.OpenKey(registry, r'SOFTWARE\Rocscience\Dips 9.0')
+        installationLocation, type = winreg.QueryValueEx(key, "Install")
+        dipsModelerInstallLocation = rf"{installationLocation}\Dips.exe"
+        return dipsModelerInstallLocation
+    
+    @staticmethod
+    def _isServerRunning(port) -> bool:
+        channel = grpc.insecure_channel('localhost:{port}'.format(port = port))
+        stub = AppServiceStub(channel)
+        stub.Ping(google_dot_protobuf_dot_empty__pb2.Empty())
+        channel.close()
+        return True
+
+    def GetModel(self) -> ProjStubRef:
+        model = self.__stub.GetProjectReference(google_dot_protobuf_dot_empty__pb2.Empty())
+        return ProjStubRef(self.__channel, model)
+    
+    def Show(self):
+        self.__stub.Show(google_dot_protobuf_dot_empty__pb2.Empty())
+    
+    def Hide(self):
+        self.__stub.Hide(google_dot_protobuf_dot_empty__pb2.Empty())
+
+    def Ping(self):
+        self.__stub.Ping(google_dot_protobuf_dot_empty__pb2.Empty())
+
+    def Close(self):
+        self.__stub.Close(google_dot_protobuf_dot_empty__pb2.Empty())
+
+
+

dips/DiscontinuityDataVal.py

@@ -0,0 +1,164 @@
+"""Generated wrapper for DiscontinuityData protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+from .CustomRowRawDataVal import CustomRowRawDataVal
+from .Vector3Val import Vector3Val
+
+class DiscontinuityDataVal:
+    """Simple wrapper for DiscontinuityData with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.DiscontinuityData
+
+
+    def __init__(self, orientation1: Optional[AngleDataVal] = None, orientation2: Optional[AngleDataVal] = None, position: Optional[Vector3Val] = None, extra_data: Optional[CustomRowRawDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the DiscontinuityData wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if orientation1 is not None:
+            self._proto_message.Orientation1.CopyFrom(orientation1.to_proto())
+            self._orientation1_wrapper = orientation1
+        if orientation2 is not None:
+            self._proto_message.Orientation2.CopyFrom(orientation2.to_proto())
+            self._orientation2_wrapper = orientation2
+        if position is not None:
+            self._proto_message.Position.CopyFrom(position.to_proto())
+            self._position_wrapper = position
+        if extra_data is not None:
+            self._proto_message.ExtraData.CopyFrom(extra_data.to_proto())
+            self._extra_data_wrapper = extra_data
+
+
+    # Properties
+
+    @property
+    def orientation1(self) -> AngleDataVal:
+        """Get the Orientation1 field as a wrapper."""
+        if not hasattr(self, '_orientation1_wrapper'):
+            self._orientation1_wrapper = AngleDataVal(proto_message=self._proto_message.Orientation1)
+        return self._orientation1_wrapper
+    
+    @orientation1.setter
+    def orientation1(self, value: AngleDataVal) -> None:
+        """Set the Orientation1 field to a wrapper."""
+        self._proto_message.Orientation1.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_orientation1_wrapper'):
+            self._orientation1_wrapper._proto_message.CopyFrom(self._proto_message.Orientation1)
+
+
+    @property
+    def orientation2(self) -> AngleDataVal:
+        """Get the Orientation2 field as a wrapper."""
+        if not hasattr(self, '_orientation2_wrapper'):
+            self._orientation2_wrapper = AngleDataVal(proto_message=self._proto_message.Orientation2)
+        return self._orientation2_wrapper
+    
+    @orientation2.setter
+    def orientation2(self, value: AngleDataVal) -> None:
+        """Set the Orientation2 field to a wrapper."""
+        self._proto_message.Orientation2.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_orientation2_wrapper'):
+            self._orientation2_wrapper._proto_message.CopyFrom(self._proto_message.Orientation2)
+
+
+    @property
+    def quantity(self) -> float:
+        """Get the Quantity field value."""
+        return self._proto_message.Quantity
+    
+    @quantity.setter
+    def quantity(self, value: float) -> None:
+        """Set the Quantity field value."""
+        self._proto_message.Quantity = value
+
+
+    @property
+    def persistence(self) -> float:
+        """Get the Persistence field value."""
+        return self._proto_message.Persistence
+    
+    @persistence.setter
+    def persistence(self, value: float) -> None:
+        """Set the Persistence field value."""
+        self._proto_message.Persistence = value
+
+
+    @property
+    def distance(self) -> float:
+        """Get the Distance field value."""
+        return self._proto_message.Distance
+    
+    @distance.setter
+    def distance(self, value: float) -> None:
+        """Set the Distance field value."""
+        self._proto_message.Distance = value
+
+
+    @property
+    def position(self) -> Vector3Val:
+        """Get the Position field as a wrapper."""
+        if not hasattr(self, '_position_wrapper'):
+            self._position_wrapper = Vector3Val(proto_message=self._proto_message.Position)
+        return self._position_wrapper
+    
+    @position.setter
+    def position(self, value: Vector3Val) -> None:
+        """Set the Position field to a wrapper."""
+        self._proto_message.Position.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_position_wrapper'):
+            self._position_wrapper._proto_message.CopyFrom(self._proto_message.Position)
+
+
+    @property
+    def extra_data(self) -> CustomRowRawDataVal:
+        """Get the ExtraData field as a wrapper."""
+        if not hasattr(self, '_extra_data_wrapper'):
+            self._extra_data_wrapper = CustomRowRawDataVal(proto_message=self._proto_message.ExtraData)
+        return self._extra_data_wrapper
+    
+    @extra_data.setter
+    def extra_data(self, value: CustomRowRawDataVal) -> None:
+        """Set the ExtraData field to a wrapper."""
+        self._proto_message.ExtraData.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_extra_data_wrapper'):
+            self._extra_data_wrapper._proto_message.CopyFrom(self._proto_message.ExtraData)
+
+
+    # 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/EllipseToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .EllipseToolEntityInfoVal import EllipseToolEntityInfoVal
+from .EllipseToolEntityInfoVal import EllipseToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class EllipseToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_EllipseToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> EllipseToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.EllipseToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return EllipseToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveEllipseTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_EllipseToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveEllipseTool(functionParam)
+        
+
+    def SetEllipseToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_EllipseToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetEllipseToolVisibility(functionParam)
+        
+
+    def UpdateEllipseTool(self,  EllipseToolEntityInfo: EllipseToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_EllipseToolEntityInfo_EllipseToolEntityInfo(This=self.__modelRef,  Input1=(EllipseToolEntityInfo.to_proto() if hasattr(EllipseToolEntityInfo, 'to_proto') else EllipseToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateEllipseTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/EllipseToolEntityInfoVal.py

@@ -0,0 +1,153 @@
+"""Generated wrapper for EllipseToolEntityInfo 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 EllipseToolEntityInfoVal:
+    """Simple wrapper for EllipseToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.EllipseToolEntityInfo
+
+
+    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 EllipseToolEntityInfo 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/FillFormatVal.py

@@ -0,0 +1,83 @@
+"""Generated wrapper for FillFormat protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+
+class FillFormatVal:
+    """Simple wrapper for FillFormat with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.FillFormat
+
+
+    def __init__(self, fill_color: Optional[ColorSurrogateVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the FillFormat wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if fill_color is not None:
+            self._proto_message.FillColor.CopyFrom(fill_color.to_proto())
+            self._fill_color_wrapper = fill_color
+
+
+    # Properties
+
+    @property
+    def apply_fill(self) -> bool:
+        """Get the ApplyFill field value."""
+        return self._proto_message.ApplyFill
+    
+    @apply_fill.setter
+    def apply_fill(self, value: bool) -> None:
+        """Set the ApplyFill field value."""
+        self._proto_message.ApplyFill = 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)
+
+
+    # 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/FoldEntityInfoRef.py

@@ -0,0 +1,23 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .FoldEntityInfoVal import FoldEntityInfoVal
+
+class FoldEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_FoldEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        
+    
+    def GetValue(self) -> FoldEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.FoldEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return FoldEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+ 

dips/FoldEntityInfoVal.py

@@ -0,0 +1,103 @@
+"""Generated wrapper for FoldEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+from .FoldWindowEntityInfoVal import FoldWindowEntityInfoVal
+
+class FoldEntityInfoVal:
+    """Simple wrapper for FoldEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.FoldEntityInfo
+
+
+    def __init__(self, color: Optional[ColorSurrogateVal] = None, fold_window_entity_info: Optional[FoldWindowEntityInfoVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the FoldEntityInfo 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 fold_window_entity_info is not None:
+            self._proto_message.FoldWindowEntityInfo.CopyFrom(fold_window_entity_info.to_proto())
+            self._fold_window_entity_info_wrapper = fold_window_entity_info
+
+
+    # Properties
+
+    @property
+    def id(self) -> str:
+        """Get the ID field value."""
+        return self._proto_message.ID
+    
+    @id.setter
+    def id(self, value: str) -> None:
+        """Set the ID field value."""
+        self._proto_message.ID = 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 fold_window_entity_info(self) -> FoldWindowEntityInfoVal:
+        """Get the FoldWindowEntityInfo field as a wrapper."""
+        if not hasattr(self, '_fold_window_entity_info_wrapper'):
+            self._fold_window_entity_info_wrapper = FoldWindowEntityInfoVal(proto_message=self._proto_message.FoldWindowEntityInfo)
+        return self._fold_window_entity_info_wrapper
+    
+    @fold_window_entity_info.setter
+    def fold_window_entity_info(self, value: FoldWindowEntityInfoVal) -> None:
+        """Set the FoldWindowEntityInfo field to a wrapper."""
+        self._proto_message.FoldWindowEntityInfo.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_fold_window_entity_info_wrapper'):
+            self._fold_window_entity_info_wrapper._proto_message.CopyFrom(self._proto_message.FoldWindowEntityInfo)
+
+
+    # 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})"