DipsScripting 9.1.0__py3-none-any.whl

dips/ClusterWindowVal.py

@@ -0,0 +1,190 @@
+"""Generated wrapper for ClusterWindow protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AutomaticClusterAnalysisSettingsVal import AutomaticClusterAnalysisSettingsVal
+from .FullDataFormatVal import FullDataFormatVal
+from .TrendPlungeVal import TrendPlungeVal
+from .DataFilterRef import DataFilterRef
+
+class ClusterWindowVal:
+    """Simple wrapper for ClusterWindow with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ClusterWindow
+
+
+    def __init__(self, cluster_settings: Optional[AutomaticClusterAnalysisSettingsVal] = None, cluster_filter: Optional[DataFilterRef] = None, cluster_center: Optional[TrendPlungeVal] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the ClusterWindow 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 cluster_settings is not None:
+            self._proto_message.ClusterSettings.CopyFrom(cluster_settings.to_proto())
+            self._cluster_settings_wrapper = cluster_settings
+        if cluster_filter is not None:
+            self.cluster_filter = cluster_filter
+        if cluster_center is not None:
+            self._proto_message.ClusterCenter.CopyFrom(cluster_center.to_proto())
+            self._cluster_center_wrapper = cluster_center
+
+
+    # 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 cluster_id(self) -> int:
+        """Get the ClusterID field value."""
+        return self._proto_message.ClusterID
+    
+    @cluster_id.setter
+    def cluster_id(self, value: int) -> None:
+        """Set the ClusterID field value."""
+        self._proto_message.ClusterID = value
+
+
+    @property
+    def cluster_labels(self) -> list:
+        """Get the ClusterLabels field as a list."""
+        return _ProtobufListWrapper(self._proto_message.ClusterLabels)
+    
+    @cluster_labels.setter
+    def cluster_labels(self, value: list) -> None:
+        """Set the ClusterLabels field to a list."""
+        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.ClusterLabels[:] = []
+        self._proto_message.ClusterLabels.extend(value)
+
+
+    @property
+    def cluster_settings(self) -> AutomaticClusterAnalysisSettingsVal:
+        """Get the ClusterSettings field as a wrapper."""
+        if not hasattr(self, '_cluster_settings_wrapper'):
+            self._cluster_settings_wrapper = AutomaticClusterAnalysisSettingsVal(proto_message=self._proto_message.ClusterSettings)
+        return self._cluster_settings_wrapper
+    
+    @cluster_settings.setter
+    def cluster_settings(self, value: AutomaticClusterAnalysisSettingsVal) -> None:
+        """Set the ClusterSettings field to a wrapper."""
+        self._proto_message.ClusterSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_cluster_settings_wrapper'):
+            self._cluster_settings_wrapper._proto_message.CopyFrom(self._proto_message.ClusterSettings)
+
+
+    @property
+    def cluster_filter(self) -> DataFilterRef:
+        """Get the ClusterFilter field as a reference."""
+        return DataFilterRef(self.__channelToConnectOn, self._proto_message.ClusterFilter)
+    
+    @cluster_filter.setter
+    def cluster_filter(self, value: DataFilterRef) -> None:
+        """Set the ClusterFilter field to a reference."""
+        self._proto_message.ClusterFilter.CopyFrom(value.get_model_ref())
+
+
+    @property
+    def used_column_headers(self) -> List[FullDataFormatVal]:
+        """Get the UsedColumnHeaders field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.UsedColumnHeaders, FullDataFormatVal)
+    
+    @used_column_headers.setter
+    def used_column_headers(self, value: List[FullDataFormatVal]) -> None:
+        """Set the UsedColumnHeaders 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.UsedColumnHeaders[:] = []
+        for item in value:
+            self._proto_message.UsedColumnHeaders.append(item.to_proto())
+
+
+    @property
+    def cluster_bearings(self) -> List[TrendPlungeVal]:
+        """Get the ClusterBearings field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.ClusterBearings, TrendPlungeVal)
+    
+    @cluster_bearings.setter
+    def cluster_bearings(self, value: List[TrendPlungeVal]) -> None:
+        """Set the ClusterBearings 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.ClusterBearings[:] = []
+        for item in value:
+            self._proto_message.ClusterBearings.append(item.to_proto())
+
+
+    @property
+    def cluster_center(self) -> TrendPlungeVal:
+        """Get the ClusterCenter field as a wrapper."""
+        if not hasattr(self, '_cluster_center_wrapper'):
+            self._cluster_center_wrapper = TrendPlungeVal(proto_message=self._proto_message.ClusterCenter)
+        return self._cluster_center_wrapper
+    
+    @cluster_center.setter
+    def cluster_center(self, value: TrendPlungeVal) -> None:
+        """Set the ClusterCenter field to a wrapper."""
+        self._proto_message.ClusterCenter.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_cluster_center_wrapper'):
+            self._cluster_center_wrapper._proto_message.CopyFrom(self._proto_message.ClusterCenter)
+
+
+    @property
+    def is_wrapped_cluster(self) -> bool:
+        """Get the IsWrappedCluster field value."""
+        return self._proto_message.IsWrappedCluster
+    
+    @is_wrapped_cluster.setter
+    def is_wrapped_cluster(self, value: bool) -> None:
+        """Set the IsWrappedCluster field value."""
+        self._proto_message.IsWrappedCluster = 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/ColorSurrogateVal.py

@@ -0,0 +1,95 @@
+"""Generated wrapper for ColorSurrogate protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class ColorSurrogateVal:
+    """Simple wrapper for ColorSurrogate with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ColorSurrogate
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the ColorSurrogate 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 a(self) -> int:
+        """Get the A field value."""
+        return self._proto_message.A
+    
+    @a.setter
+    def a(self, value: int) -> None:
+        """Set the A field value."""
+        self._proto_message.A = value
+
+
+    @property
+    def r(self) -> int:
+        """Get the R field value."""
+        return self._proto_message.R
+    
+    @r.setter
+    def r(self, value: int) -> None:
+        """Set the R field value."""
+        self._proto_message.R = value
+
+
+    @property
+    def g(self) -> int:
+        """Get the G field value."""
+        return self._proto_message.G
+    
+    @g.setter
+    def g(self, value: int) -> None:
+        """Set the G field value."""
+        self._proto_message.G = value
+
+
+    @property
+    def b(self) -> int:
+        """Get the B field value."""
+        return self._proto_message.B
+    
+    @b.setter
+    def b(self, value: int) -> None:
+        """Set the B field value."""
+        self._proto_message.B = 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/ConeToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .ConeToolEntityInfoVal import ConeToolEntityInfoVal
+from .ConeToolEntityInfoVal import ConeToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class ConeToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_ConeToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> ConeToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.ConeToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return ConeToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveConeTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ConeToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveConeTool(functionParam)
+        
+
+    def SetConeToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ConeToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetConeToolVisibility(functionParam)
+        
+
+    def UpdateConeTool(self,  ConeToolEntityInfo: ConeToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ConeToolEntityInfo_ConeToolEntityInfo(This=self.__modelRef,  Input1=(ConeToolEntityInfo.to_proto() if hasattr(ConeToolEntityInfo, 'to_proto') else ConeToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateConeTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/ConeToolEntityInfoVal.py

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

@@ -0,0 +1,92 @@
+"""Generated wrapper for Cone 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 ConeVal:
+    """Simple wrapper for Cone with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.Cone
+
+
+    def __init__(self, center: Optional[TrendPlungeVal] = None, cone_angle: Optional[AngleDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the Cone wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if center is not None:
+            self._proto_message.Center.CopyFrom(center.to_proto())
+            self._center_wrapper = center
+        if cone_angle is not None:
+            self._proto_message.ConeAngle.CopyFrom(cone_angle.to_proto())
+            self._cone_angle_wrapper = cone_angle
+
+
+    # Properties
+
+    @property
+    def center(self) -> TrendPlungeVal:
+        """Get the Center field as a wrapper."""
+        if not hasattr(self, '_center_wrapper'):
+            self._center_wrapper = TrendPlungeVal(proto_message=self._proto_message.Center)
+        return self._center_wrapper
+    
+    @center.setter
+    def center(self, value: TrendPlungeVal) -> None:
+        """Set the Center field to a wrapper."""
+        self._proto_message.Center.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_center_wrapper'):
+            self._center_wrapper._proto_message.CopyFrom(self._proto_message.Center)
+
+
+    @property
+    def cone_angle(self) -> AngleDataVal:
+        """Get the ConeAngle field as a wrapper."""
+        if not hasattr(self, '_cone_angle_wrapper'):
+            self._cone_angle_wrapper = AngleDataVal(proto_message=self._proto_message.ConeAngle)
+        return self._cone_angle_wrapper
+    
+    @cone_angle.setter
+    def cone_angle(self, value: AngleDataVal) -> None:
+        """Set the ConeAngle field to a wrapper."""
+        self._proto_message.ConeAngle.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_cone_angle_wrapper'):
+            self._cone_angle_wrapper._proto_message.CopyFrom(self._proto_message.ConeAngle)
+
+
+    # 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/ContourEntityVisibilityVal.py

@@ -0,0 +1,132 @@
+"""Generated wrapper for ContourEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ContourOptionsVal import ContourOptionsVal
+
+class ContourEntityVisibilityVal:
+    """Simple wrapper for ContourEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ContourEntityVisibility
+
+
+    def __init__(self, pole_vector_density_contour_options: Optional[ContourOptionsVal] = None, intersection_vector_density_contour_options: Optional[ContourOptionsVal] = None, quantitative_contour_options: Optional[ContourOptionsVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the ContourEntityVisibility wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if pole_vector_density_contour_options is not None:
+            self._proto_message.PoleVectorDensityContourOptions.CopyFrom(pole_vector_density_contour_options.to_proto())
+            self._pole_vector_density_contour_options_wrapper = pole_vector_density_contour_options
+        if intersection_vector_density_contour_options is not None:
+            self._proto_message.IntersectionVectorDensityContourOptions.CopyFrom(intersection_vector_density_contour_options.to_proto())
+            self._intersection_vector_density_contour_options_wrapper = intersection_vector_density_contour_options
+        if quantitative_contour_options is not None:
+            self._proto_message.QuantitativeContourOptions.CopyFrom(quantitative_contour_options.to_proto())
+            self._quantitative_contour_options_wrapper = quantitative_contour_options
+
+
+    # Properties
+
+    @property
+    def is_visible(self) -> bool:
+        """Get the IsVisible field value."""
+        return self._proto_message.IsVisible
+    
+    @is_visible.setter
+    def is_visible(self, value: bool) -> None:
+        """Set the IsVisible field value."""
+        self._proto_message.IsVisible = value
+
+
+    @property
+    def contour_type(self) -> Any:
+        """Get the ContourType field value."""
+        return self._proto_message.ContourType
+    
+    @contour_type.setter
+    def contour_type(self, value: Any) -> None:
+        """Set the ContourType field value."""
+        self._proto_message.ContourType = value
+
+
+    @property
+    def pole_vector_density_contour_options(self) -> ContourOptionsVal:
+        """Get the PoleVectorDensityContourOptions field as a wrapper."""
+        if not hasattr(self, '_pole_vector_density_contour_options_wrapper'):
+            self._pole_vector_density_contour_options_wrapper = ContourOptionsVal(proto_message=self._proto_message.PoleVectorDensityContourOptions)
+        return self._pole_vector_density_contour_options_wrapper
+    
+    @pole_vector_density_contour_options.setter
+    def pole_vector_density_contour_options(self, value: ContourOptionsVal) -> None:
+        """Set the PoleVectorDensityContourOptions field to a wrapper."""
+        self._proto_message.PoleVectorDensityContourOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_pole_vector_density_contour_options_wrapper'):
+            self._pole_vector_density_contour_options_wrapper._proto_message.CopyFrom(self._proto_message.PoleVectorDensityContourOptions)
+
+
+    @property
+    def intersection_vector_density_contour_options(self) -> ContourOptionsVal:
+        """Get the IntersectionVectorDensityContourOptions field as a wrapper."""
+        if not hasattr(self, '_intersection_vector_density_contour_options_wrapper'):
+            self._intersection_vector_density_contour_options_wrapper = ContourOptionsVal(proto_message=self._proto_message.IntersectionVectorDensityContourOptions)
+        return self._intersection_vector_density_contour_options_wrapper
+    
+    @intersection_vector_density_contour_options.setter
+    def intersection_vector_density_contour_options(self, value: ContourOptionsVal) -> None:
+        """Set the IntersectionVectorDensityContourOptions field to a wrapper."""
+        self._proto_message.IntersectionVectorDensityContourOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_intersection_vector_density_contour_options_wrapper'):
+            self._intersection_vector_density_contour_options_wrapper._proto_message.CopyFrom(self._proto_message.IntersectionVectorDensityContourOptions)
+
+
+    @property
+    def quantitative_contour_options(self) -> ContourOptionsVal:
+        """Get the QuantitativeContourOptions field as a wrapper."""
+        if not hasattr(self, '_quantitative_contour_options_wrapper'):
+            self._quantitative_contour_options_wrapper = ContourOptionsVal(proto_message=self._proto_message.QuantitativeContourOptions)
+        return self._quantitative_contour_options_wrapper
+    
+    @quantitative_contour_options.setter
+    def quantitative_contour_options(self, value: ContourOptionsVal) -> None:
+        """Set the QuantitativeContourOptions field to a wrapper."""
+        self._proto_message.QuantitativeContourOptions.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_quantitative_contour_options_wrapper'):
+            self._quantitative_contour_options_wrapper._proto_message.CopyFrom(self._proto_message.QuantitativeContourOptions)
+
+
+    # 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})"