DipsScripting 9.1.0__py3-none-any.whl

dips/SetVersusSetVal.py

@@ -0,0 +1,82 @@
+"""Generated wrapper for SetVersusSet protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .SetEntityInfoRef import SetEntityInfoRef
+
+class SetVersusSetVal:
+    """Simple wrapper for SetVersusSet with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetVersusSet
+
+
+    def __init__(self, set_a: Optional[SetEntityInfoRef] = None, set_b: Optional[SetEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the SetVersusSet 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 set_a is not None:
+            self.set_a = set_a
+        if set_b is not None:
+            self.set_b = set_b
+
+
+    # Properties
+
+    @property
+    def set_a(self) -> SetEntityInfoRef:
+        """Get the SetA field as a reference."""
+        return SetEntityInfoRef(self.__channelToConnectOn, self._proto_message.SetA)
+    
+    @set_a.setter
+    def set_a(self, value: SetEntityInfoRef) -> None:
+        """Set the SetA field to a reference."""
+        self._proto_message.SetA.CopyFrom(value.get_model_ref())
+
+
+    @property
+    def set_b(self) -> SetEntityInfoRef:
+        """Get the SetB field as a reference."""
+        return SetEntityInfoRef(self.__channelToConnectOn, self._proto_message.SetB)
+    
+    @set_b.setter
+    def set_b(self, value: SetEntityInfoRef) -> None:
+        """Set the SetB field to a reference."""
+        self._proto_message.SetB.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/SetWindowEntityInfoVal.py

@@ -0,0 +1,183 @@
+"""Generated wrapper for SetWindowEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .CircularWindowVal import CircularWindowVal
+from .ClusterWindowVal import ClusterWindowVal
+from .ColorSurrogateVal import ColorSurrogateVal
+from .CurvedWindowVal import CurvedWindowVal
+from .SetStatisticsSettingsVal import SetStatisticsSettingsVal
+from .WrappedFreehandWindowVal import WrappedFreehandWindowVal
+
+class SetWindowEntityInfoVal:
+    """Simple wrapper for SetWindowEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetWindowEntityInfo
+
+
+    def __init__(self, color: Optional[ColorSurrogateVal] = None, statistics_settings: Optional[SetStatisticsSettingsVal] = None, circular_set_window: Optional[CircularWindowVal] = None, curved_set_window: Optional[CurvedWindowVal] = None, wrapped_freehand_set_window: Optional[WrappedFreehandWindowVal] = None, cluster_set_window: Optional[ClusterWindowVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the SetWindowEntityInfo 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 statistics_settings is not None:
+            self._proto_message.StatisticsSettings.CopyFrom(statistics_settings.to_proto())
+            self._statistics_settings_wrapper = statistics_settings
+        if circular_set_window is not None:
+            self._proto_message.CircularSetWindow.CopyFrom(circular_set_window.to_proto())
+            self._circular_set_window_wrapper = circular_set_window
+        if curved_set_window is not None:
+            self._proto_message.CurvedSetWindow.CopyFrom(curved_set_window.to_proto())
+            self._curved_set_window_wrapper = curved_set_window
+        if wrapped_freehand_set_window is not None:
+            self._proto_message.WrappedFreehandSetWindow.CopyFrom(wrapped_freehand_set_window.to_proto())
+            self._wrapped_freehand_set_window_wrapper = wrapped_freehand_set_window
+        if cluster_set_window is not None:
+            self._proto_message.ClusterSetWindow.CopyFrom(cluster_set_window.to_proto())
+            self._cluster_set_window_wrapper = cluster_set_window
+
+
+    # Properties
+
+    @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 set_window_type(self) -> Any:
+        """Get the SetWindowType field value."""
+        return self._proto_message.SetWindowType
+    
+    @set_window_type.setter
+    def set_window_type(self, value: Any) -> None:
+        """Set the SetWindowType field value."""
+        self._proto_message.SetWindowType = value
+
+
+    @property
+    def statistics_settings(self) -> SetStatisticsSettingsVal:
+        """Get the StatisticsSettings field as a wrapper."""
+        if not hasattr(self, '_statistics_settings_wrapper'):
+            self._statistics_settings_wrapper = SetStatisticsSettingsVal(proto_message=self._proto_message.StatisticsSettings)
+        return self._statistics_settings_wrapper
+    
+    @statistics_settings.setter
+    def statistics_settings(self, value: SetStatisticsSettingsVal) -> None:
+        """Set the StatisticsSettings field to a wrapper."""
+        self._proto_message.StatisticsSettings.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_statistics_settings_wrapper'):
+            self._statistics_settings_wrapper._proto_message.CopyFrom(self._proto_message.StatisticsSettings)
+
+
+    @property
+    def circular_set_window(self) -> CircularWindowVal:
+        """Get the CircularSetWindow field as a wrapper."""
+        if not hasattr(self, '_circular_set_window_wrapper'):
+            self._circular_set_window_wrapper = CircularWindowVal(proto_message=self._proto_message.CircularSetWindow)
+        return self._circular_set_window_wrapper
+    
+    @circular_set_window.setter
+    def circular_set_window(self, value: CircularWindowVal) -> None:
+        """Set the CircularSetWindow field to a wrapper."""
+        self._proto_message.CircularSetWindow.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_circular_set_window_wrapper'):
+            self._circular_set_window_wrapper._proto_message.CopyFrom(self._proto_message.CircularSetWindow)
+
+
+    @property
+    def curved_set_window(self) -> CurvedWindowVal:
+        """Get the CurvedSetWindow field as a wrapper."""
+        if not hasattr(self, '_curved_set_window_wrapper'):
+            self._curved_set_window_wrapper = CurvedWindowVal(proto_message=self._proto_message.CurvedSetWindow)
+        return self._curved_set_window_wrapper
+    
+    @curved_set_window.setter
+    def curved_set_window(self, value: CurvedWindowVal) -> None:
+        """Set the CurvedSetWindow field to a wrapper."""
+        self._proto_message.CurvedSetWindow.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_curved_set_window_wrapper'):
+            self._curved_set_window_wrapper._proto_message.CopyFrom(self._proto_message.CurvedSetWindow)
+
+
+    @property
+    def wrapped_freehand_set_window(self) -> WrappedFreehandWindowVal:
+        """Get the WrappedFreehandSetWindow field as a wrapper."""
+        if not hasattr(self, '_wrapped_freehand_set_window_wrapper'):
+            self._wrapped_freehand_set_window_wrapper = WrappedFreehandWindowVal(proto_message=self._proto_message.WrappedFreehandSetWindow)
+        return self._wrapped_freehand_set_window_wrapper
+    
+    @wrapped_freehand_set_window.setter
+    def wrapped_freehand_set_window(self, value: WrappedFreehandWindowVal) -> None:
+        """Set the WrappedFreehandSetWindow field to a wrapper."""
+        self._proto_message.WrappedFreehandSetWindow.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_wrapped_freehand_set_window_wrapper'):
+            self._wrapped_freehand_set_window_wrapper._proto_message.CopyFrom(self._proto_message.WrappedFreehandSetWindow)
+
+
+    @property
+    def cluster_set_window(self) -> ClusterWindowVal:
+        """Get the ClusterSetWindow field as a wrapper."""
+        if not hasattr(self, '_cluster_set_window_wrapper'):
+            self._cluster_set_window_wrapper = ClusterWindowVal(proto_message=self._proto_message.ClusterSetWindow)
+        return self._cluster_set_window_wrapper
+    
+    @cluster_set_window.setter
+    def cluster_set_window(self, value: ClusterWindowVal) -> None:
+        """Set the ClusterSetWindow field to a wrapper."""
+        self._proto_message.ClusterSetWindow.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_cluster_set_window_wrapper'):
+            self._cluster_set_window_wrapper._proto_message.CopyFrom(self._proto_message.ClusterSetWindow)
+
+
+    # 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/SetWindowEntityVisibilityRef.py

@@ -0,0 +1,29 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .SetWindowEntityVisibilityVal import SetWindowEntityVisibilityVal
+
+class SetWindowEntityVisibilityRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_SetWindowEntityVisibility):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> SetWindowEntityVisibilityVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.SetWindowEntityVisibility()
+        ret.MergeFromString(bytes.data)
+        return SetWindowEntityVisibilityVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def SetSetWindowEntityVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_SetWindowEntityVisibility_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetSetWindowEntityVisibility(functionParam)
+        
+
+ 

dips/SetWindowEntityVisibilityVal.py

@@ -0,0 +1,80 @@
+"""Generated wrapper for SetWindowEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .SetEntityInfoRef import SetEntityInfoRef
+
+class SetWindowEntityVisibilityVal:
+    """Simple wrapper for SetWindowEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.SetWindowEntityVisibility
+
+
+    def __init__(self, set_entity_reference: Optional[SetEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the SetWindowEntityVisibility 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 set_entity_reference is not None:
+            self.set_entity_reference = set_entity_reference
+
+
+    # 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 set_entity_reference(self) -> SetEntityInfoRef:
+        """Get the SetEntityReference field as a reference."""
+        return SetEntityInfoRef(self.__channelToConnectOn, self._proto_message.SetEntityReference)
+    
+    @set_entity_reference.setter
+    def set_entity_reference(self, value: SetEntityInfoRef) -> None:
+        """Set the SetEntityReference field to a reference."""
+        self._proto_message.SetEntityReference.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/StatisticalDistributionFilterVal.py

@@ -0,0 +1,128 @@
+"""Generated wrapper for StatisticalDistributionFilter protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class StatisticalDistributionFilterVal:
+    """Simple wrapper for StatisticalDistributionFilter with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.StatisticalDistributionFilter
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the StatisticalDistributionFilter 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 normal_distribution(self) -> bool:
+        """Get the NormalDistribution field value."""
+        return self._proto_message.NormalDistribution
+    
+    @normal_distribution.setter
+    def normal_distribution(self, value: bool) -> None:
+        """Set the NormalDistribution field value."""
+        self._proto_message.NormalDistribution = value
+
+
+    @property
+    def uniform_distribution(self) -> bool:
+        """Get the UniformDistribution field value."""
+        return self._proto_message.UniformDistribution
+    
+    @uniform_distribution.setter
+    def uniform_distribution(self, value: bool) -> None:
+        """Set the UniformDistribution field value."""
+        self._proto_message.UniformDistribution = value
+
+
+    @property
+    def triangular_distribution(self) -> bool:
+        """Get the TriangularDistribution field value."""
+        return self._proto_message.TriangularDistribution
+    
+    @triangular_distribution.setter
+    def triangular_distribution(self, value: bool) -> None:
+        """Set the TriangularDistribution field value."""
+        self._proto_message.TriangularDistribution = value
+
+
+    @property
+    def beta_distribution(self) -> bool:
+        """Get the BetaDistribution field value."""
+        return self._proto_message.BetaDistribution
+    
+    @beta_distribution.setter
+    def beta_distribution(self, value: bool) -> None:
+        """Set the BetaDistribution field value."""
+        self._proto_message.BetaDistribution = value
+
+
+    @property
+    def exponential_distribution(self) -> bool:
+        """Get the ExponentialDistribution field value."""
+        return self._proto_message.ExponentialDistribution
+    
+    @exponential_distribution.setter
+    def exponential_distribution(self, value: bool) -> None:
+        """Set the ExponentialDistribution field value."""
+        self._proto_message.ExponentialDistribution = value
+
+
+    @property
+    def lognormal_distribution(self) -> bool:
+        """Get the LognormalDistribution field value."""
+        return self._proto_message.LognormalDistribution
+    
+    @lognormal_distribution.setter
+    def lognormal_distribution(self, value: bool) -> None:
+        """Set the LognormalDistribution field value."""
+        self._proto_message.LognormalDistribution = value
+
+
+    @property
+    def gamma_distribution(self) -> bool:
+        """Get the GammaDistribution field value."""
+        return self._proto_message.GammaDistribution
+    
+    @gamma_distribution.setter
+    def gamma_distribution(self, value: bool) -> None:
+        """Set the GammaDistribution field value."""
+        self._proto_message.GammaDistribution = 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})"