DipsScripting 9.1.0__py3-none-any.whl

dips/ContourOptionsVal.py

@@ -0,0 +1,193 @@
+"""Generated wrapper for ContourOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+from .CustomRangeVal import CustomRangeVal
+
+class ContourOptionsVal:
+    """Simple wrapper for ContourOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ContourOptions
+
+
+    def __init__(self, custom_range: Optional[CustomRangeVal] = None, min_color: Optional[ColorSurrogateVal] = None, max_color: Optional[ColorSurrogateVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the ContourOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if custom_range is not None:
+            self._proto_message.CustomRange.CopyFrom(custom_range.to_proto())
+            self._custom_range_wrapper = custom_range
+        if min_color is not None:
+            self._proto_message.MinColor.CopyFrom(min_color.to_proto())
+            self._min_color_wrapper = min_color
+        if max_color is not None:
+            self._proto_message.MaxColor.CopyFrom(max_color.to_proto())
+            self._max_color_wrapper = max_color
+
+
+    # Properties
+
+    @property
+    def custom_range(self) -> CustomRangeVal:
+        """Get the CustomRange field as a wrapper."""
+        if not hasattr(self, '_custom_range_wrapper'):
+            self._custom_range_wrapper = CustomRangeVal(proto_message=self._proto_message.CustomRange)
+        return self._custom_range_wrapper
+    
+    @custom_range.setter
+    def custom_range(self, value: CustomRangeVal) -> None:
+        """Set the CustomRange field to a wrapper."""
+        self._proto_message.CustomRange.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_custom_range_wrapper'):
+            self._custom_range_wrapper._proto_message.CopyFrom(self._proto_message.CustomRange)
+
+
+    @property
+    def intervals(self) -> int:
+        """Get the Intervals field value."""
+        return self._proto_message.Intervals
+    
+    @intervals.setter
+    def intervals(self, value: int) -> None:
+        """Set the Intervals field value."""
+        self._proto_message.Intervals = value
+
+
+    @property
+    def contour_mode(self) -> Any:
+        """Get the ContourMode field value."""
+        return self._proto_message.ContourMode
+    
+    @contour_mode.setter
+    def contour_mode(self, value: Any) -> None:
+        """Set the ContourMode field value."""
+        self._proto_message.ContourMode = value
+
+
+    @property
+    def min_color(self) -> ColorSurrogateVal:
+        """Get the MinColor field as a wrapper."""
+        if not hasattr(self, '_min_color_wrapper'):
+            self._min_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.MinColor)
+        return self._min_color_wrapper
+    
+    @min_color.setter
+    def min_color(self, value: ColorSurrogateVal) -> None:
+        """Set the MinColor field to a wrapper."""
+        self._proto_message.MinColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_min_color_wrapper'):
+            self._min_color_wrapper._proto_message.CopyFrom(self._proto_message.MinColor)
+
+
+    @property
+    def max_color(self) -> ColorSurrogateVal:
+        """Get the MaxColor field as a wrapper."""
+        if not hasattr(self, '_max_color_wrapper'):
+            self._max_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.MaxColor)
+        return self._max_color_wrapper
+    
+    @max_color.setter
+    def max_color(self, value: ColorSurrogateVal) -> None:
+        """Set the MaxColor field to a wrapper."""
+        self._proto_message.MaxColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_max_color_wrapper'):
+            self._max_color_wrapper._proto_message.CopyFrom(self._proto_message.MaxColor)
+
+
+    @property
+    def color_interpolation_method(self) -> Any:
+        """Get the ColorInterpolationMethod field value."""
+        return self._proto_message.ColorInterpolationMethod
+    
+    @color_interpolation_method.setter
+    def color_interpolation_method(self, value: Any) -> None:
+        """Set the ColorInterpolationMethod field value."""
+        self._proto_message.ColorInterpolationMethod = value
+
+
+    @property
+    def fill_below_minimum(self) -> bool:
+        """Get the FillBelowMinimum field value."""
+        return self._proto_message.FillBelowMinimum
+    
+    @fill_below_minimum.setter
+    def fill_below_minimum(self, value: bool) -> None:
+        """Set the FillBelowMinimum field value."""
+        self._proto_message.FillBelowMinimum = value
+
+
+    @property
+    def fill_above_maximum(self) -> bool:
+        """Get the FillAboveMaximum field value."""
+        return self._proto_message.FillAboveMaximum
+    
+    @fill_above_maximum.setter
+    def fill_above_maximum(self, value: bool) -> None:
+        """Set the FillAboveMaximum field value."""
+        self._proto_message.FillAboveMaximum = value
+
+
+    @property
+    def custom_colors(self) -> List[ColorSurrogateVal]:
+        """Get the CustomColors field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.CustomColors, ColorSurrogateVal)
+    
+    @custom_colors.setter
+    def custom_colors(self, value: List[ColorSurrogateVal]) -> None:
+        """Set the CustomColors 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.CustomColors[:] = []
+        for item in value:
+            self._proto_message.CustomColors.append(item.to_proto())
+
+
+    @property
+    def contour_color_table_method(self) -> Any:
+        """Get the ContourColorTableMethod field value."""
+        return self._proto_message.ContourColorTableMethod
+    
+    @contour_color_table_method.setter
+    def contour_color_table_method(self, value: Any) -> None:
+        """Set the ContourColorTableMethod field value."""
+        self._proto_message.ContourColorTableMethod = 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/CumulativeChartViewRef.py

@@ -0,0 +1,42 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .CumulativeChartViewVal import CumulativeChartViewVal
+from .DataFilterRef import DataFilterRef as DataFilter_RefType
+
+class CumulativeChartViewRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_CumulativeChartView):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__CumulativeChartServicesStubLocal = DipsAPI_pb2_grpc.CumulativeChartServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> CumulativeChartViewVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.CumulativeChartView()
+        ret.MergeFromString(bytes.data)
+        return CumulativeChartViewVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def CloseCumulativeChartView(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_CumulativeChartView(This=self.__modelRef)
+        ret = self.__CumulativeChartServicesStubLocal.CloseCumulativeChartView(functionParam)
+        
+
+    def GetActiveDataFilter(self) -> DataFilter_RefType:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_CumulativeChartView(This=self.__modelRef)
+        ret = self.__CumulativeChartServicesStubLocal.GetActiveDataFilter(functionParam)
+        
+        return DataFilter_RefType(self.__channelToConnectOn, ret)
+        
+
+    def SetActiveDataFilter(self,  DataFilter: DataFilter_RefType):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_CumulativeChartView_ProtoReference_DataFilter(This=self.__modelRef,  Input1=DataFilter.get_model_ref())
+        ret = self.__CumulativeChartServicesStubLocal.SetActiveDataFilter(functionParam)
+        
+
+ 

dips/CumulativeChartViewVal.py

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

@@ -0,0 +1,94 @@
+"""Generated wrapper for CumulativePlotSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .DataDescriptorVal import DataDescriptorVal
+
+class CumulativePlotSettingsVal:
+    """Simple wrapper for CumulativePlotSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.CumulativePlotSettings
+
+
+    def __init__(self, selected_column: Optional[DataDescriptorVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the CumulativePlotSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if selected_column is not None:
+            self._proto_message.SelectedColumn.CopyFrom(selected_column.to_proto())
+            self._selected_column_wrapper = selected_column
+
+
+    # Properties
+
+    @property
+    def selected_column(self) -> DataDescriptorVal:
+        """Get the SelectedColumn field as a wrapper."""
+        if not hasattr(self, '_selected_column_wrapper'):
+            self._selected_column_wrapper = DataDescriptorVal(proto_message=self._proto_message.SelectedColumn)
+        return self._selected_column_wrapper
+    
+    @selected_column.setter
+    def selected_column(self, value: DataDescriptorVal) -> None:
+        """Set the SelectedColumn field to a wrapper."""
+        self._proto_message.SelectedColumn.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_selected_column_wrapper'):
+            self._selected_column_wrapper._proto_message.CopyFrom(self._proto_message.SelectedColumn)
+
+
+    @property
+    def num_bins(self) -> int:
+        """Get the NumBins field value."""
+        return self._proto_message.NumBins
+    
+    @num_bins.setter
+    def num_bins(self, value: int) -> None:
+        """Set the NumBins field value."""
+        self._proto_message.NumBins = value
+
+
+    @property
+    def is_weighted(self) -> bool:
+        """Get the IsWeighted field value."""
+        return self._proto_message.IsWeighted
+    
+    @is_weighted.setter
+    def is_weighted(self, value: bool) -> None:
+        """Set the IsWeighted field value."""
+        self._proto_message.IsWeighted = value
+
+
+    # Utility methods
+
+    def to_proto(self):
+        """Get the underlying protobuf message."""
+        return self._proto_message
+    
+    @classmethod
+    def from_proto(cls, proto_message):
+        """Create wrapper from existing protobuf message."""
+        wrapper = cls()
+        wrapper._proto_message.CopyFrom(proto_message)
+        return wrapper
+    
+    def copy(self):
+        """Create a copy of this wrapper."""
+        new_wrapper = self.__class__()
+        new_wrapper._proto_message.CopyFrom(self._proto_message)
+        return new_wrapper
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"{self.__class__.__name__}({self._proto_message})"

dips/CurvedWindowVal.py

@@ -0,0 +1,102 @@
+"""Generated wrapper for CurvedWindow protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .TrendPlungeVal import TrendPlungeVal
+
+class CurvedWindowVal:
+    """Simple wrapper for CurvedWindow with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.CurvedWindow
+
+
+    def __init__(self, first_corner: Optional[TrendPlungeVal] = None, second_corner: Optional[TrendPlungeVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the CurvedWindow wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        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 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 first_corner(self) -> TrendPlungeVal:
+        """Get the FirstCorner field as a wrapper."""
+        if not hasattr(self, '_first_corner_wrapper'):
+            self._first_corner_wrapper = TrendPlungeVal(proto_message=self._proto_message.FirstCorner)
+        return self._first_corner_wrapper
+    
+    @first_corner.setter
+    def first_corner(self, value: TrendPlungeVal) -> 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) -> TrendPlungeVal:
+        """Get the SecondCorner field as a wrapper."""
+        if not hasattr(self, '_second_corner_wrapper'):
+            self._second_corner_wrapper = TrendPlungeVal(proto_message=self._proto_message.SecondCorner)
+        return self._second_corner_wrapper
+    
+    @second_corner.setter
+    def second_corner(self, value: TrendPlungeVal) -> 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/CustomColumnCollectionVal.py

@@ -0,0 +1,69 @@
+"""Generated wrapper for CustomColumnCollection protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .FullDataFormatVal import FullDataFormatVal
+
+class CustomColumnCollectionVal:
+    """Simple wrapper for CustomColumnCollection with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.CustomColumnCollection
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the CustomColumnCollection 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 custom_columns(self) -> List[FullDataFormatVal]:
+        """Get the CustomColumns field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.CustomColumns, FullDataFormatVal)
+    
+    @custom_columns.setter
+    def custom_columns(self, value: List[FullDataFormatVal]) -> None:
+        """Set the CustomColumns 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.CustomColumns[:] = []
+        for item in value:
+            self._proto_message.CustomColumns.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})"