DipsScripting 9.1.0__py3-none-any.whl

dips/FoldEntityOptionsVal.py

@@ -0,0 +1,106 @@
+"""Generated wrapper for FoldEntityOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class FoldEntityOptionsVal:
+    """Simple wrapper for FoldEntityOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.FoldEntityOptions
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the FoldEntityOptions wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+
+
+    # Properties
+
+    @property
+    def show_plane(self) -> bool:
+        """Get the ShowPlane field value."""
+        return self._proto_message.ShowPlane
+    
+    @show_plane.setter
+    def show_plane(self, value: bool) -> None:
+        """Set the ShowPlane field value."""
+        self._proto_message.ShowPlane = value
+
+
+    @property
+    def show_marker_ticks(self) -> bool:
+        """Get the ShowMarkerTicks field value."""
+        return self._proto_message.ShowMarkerTicks
+    
+    @show_marker_ticks.setter
+    def show_marker_ticks(self, value: bool) -> None:
+        """Set the ShowMarkerTicks field value."""
+        self._proto_message.ShowMarkerTicks = value
+
+
+    @property
+    def show_pole(self) -> bool:
+        """Get the ShowPole field value."""
+        return self._proto_message.ShowPole
+    
+    @show_pole.setter
+    def show_pole(self, value: bool) -> None:
+        """Set the ShowPole field value."""
+        self._proto_message.ShowPole = value
+
+
+    @property
+    def show_pole_label(self) -> bool:
+        """Get the ShowPoleLabel field value."""
+        return self._proto_message.ShowPoleLabel
+    
+    @show_pole_label.setter
+    def show_pole_label(self, value: bool) -> None:
+        """Set the ShowPoleLabel field value."""
+        self._proto_message.ShowPoleLabel = value
+
+
+    @property
+    def show_plane_label(self) -> bool:
+        """Get the ShowPlaneLabel field value."""
+        return self._proto_message.ShowPlaneLabel
+    
+    @show_plane_label.setter
+    def show_plane_label(self, value: bool) -> None:
+        """Set the ShowPlaneLabel field value."""
+        self._proto_message.ShowPlaneLabel = 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/FoldEntityVisibilityRef.py

@@ -0,0 +1,38 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .FoldEntityVisibilityVal import FoldEntityVisibilityVal
+from .FoldEntityVisibilityVal import FoldEntityVisibilityVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class FoldEntityVisibilityRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_FoldEntityVisibility):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> FoldEntityVisibilityVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.FoldEntityVisibility()
+        ret.MergeFromString(bytes.data)
+        return FoldEntityVisibilityVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def SetFoldEntityOptions(self,  FoldEntityVisibility: FoldEntityVisibilityVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_FoldEntityVisibility_FoldEntityVisibility(This=self.__modelRef,  Input1=(FoldEntityVisibility.to_proto() if hasattr(FoldEntityVisibility, 'to_proto') else FoldEntityVisibility))
+        ret = self.__EntityServicesStubLocal.SetFoldEntityOptions(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+    def SetFoldEntityVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_FoldEntityVisibility_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetFoldEntityVisibility(functionParam)
+        
+
+ 

dips/FoldEntityVisibilityVal.py

@@ -0,0 +1,100 @@
+"""Generated wrapper for FoldEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .FoldEntityOptionsVal import FoldEntityOptionsVal
+from .FoldEntityInfoRef import FoldEntityInfoRef
+
+class FoldEntityVisibilityVal:
+    """Simple wrapper for FoldEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.FoldEntityVisibility
+
+
+    def __init__(self, options: Optional[FoldEntityOptionsVal] = None, fold_entity_reference: Optional[FoldEntityInfoRef] = None, proto_message: Optional[Any] = None, channel_to_connect_on: Optional[Any] = None):
+        """Initialize the FoldEntityVisibility 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 options is not None:
+            self._proto_message.Options.CopyFrom(options.to_proto())
+            self._options_wrapper = options
+        if fold_entity_reference is not None:
+            self.fold_entity_reference = fold_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 options(self) -> FoldEntityOptionsVal:
+        """Get the Options field as a wrapper."""
+        if not hasattr(self, '_options_wrapper'):
+            self._options_wrapper = FoldEntityOptionsVal(proto_message=self._proto_message.Options)
+        return self._options_wrapper
+    
+    @options.setter
+    def options(self, value: FoldEntityOptionsVal) -> None:
+        """Set the Options field to a wrapper."""
+        self._proto_message.Options.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_options_wrapper'):
+            self._options_wrapper._proto_message.CopyFrom(self._proto_message.Options)
+
+
+    @property
+    def fold_entity_reference(self) -> FoldEntityInfoRef:
+        """Get the FoldEntityReference field as a reference."""
+        return FoldEntityInfoRef(self.__channelToConnectOn, self._proto_message.FoldEntityReference)
+    
+    @fold_entity_reference.setter
+    def fold_entity_reference(self, value: FoldEntityInfoRef) -> None:
+        """Set the FoldEntityReference field to a reference."""
+        self._proto_message.FoldEntityReference.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/FoldWindowEntityInfoVal.py

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

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

dips/FoldWindowEntityVisibilityVal.py

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

@@ -0,0 +1,80 @@
+"""Generated wrapper for FreehandWindow protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .TrendPlungeVal import TrendPlungeVal
+
+class FreehandWindowVal:
+    """Simple wrapper for FreehandWindow with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.FreehandWindow
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the FreehandWindow 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 polygon(self) -> List[TrendPlungeVal]:
+        """Get the Polygon field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Polygon, TrendPlungeVal)
+    
+    @polygon.setter
+    def polygon(self, value: List[TrendPlungeVal]) -> None:
+        """Set the Polygon 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.Polygon[:] = []
+        for item in value:
+            self._proto_message.Polygon.append(item.to_proto())
+
+
+    @property
+    def is_wrapped(self) -> bool:
+        """Get the IsWrapped field value."""
+        return self._proto_message.IsWrapped
+    
+    @is_wrapped.setter
+    def is_wrapped(self, value: bool) -> None:
+        """Set the IsWrapped field value."""
+        self._proto_message.IsWrapped = 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/FullDataFormatVal.py

@@ -0,0 +1,92 @@
+"""Generated wrapper for FullDataFormat protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .DataDescriptorVal import DataDescriptorVal
+from .DataFormatterVal import DataFormatterVal
+
+class FullDataFormatVal:
+    """Simple wrapper for FullDataFormat with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.FullDataFormat
+
+
+    def __init__(self, descriptor: Optional[DataDescriptorVal] = None, format: Optional[DataFormatterVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the FullDataFormat wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if descriptor is not None:
+            self._proto_message.Descriptor.CopyFrom(descriptor.to_proto())
+            self._descriptor_wrapper = descriptor
+        if format is not None:
+            self._proto_message.Format.CopyFrom(format.to_proto())
+            self._format_wrapper = format
+
+
+    # Properties
+
+    @property
+    def descriptor(self) -> DataDescriptorVal:
+        """Get the Descriptor field as a wrapper."""
+        if not hasattr(self, '_descriptor_wrapper'):
+            self._descriptor_wrapper = DataDescriptorVal(proto_message=self._proto_message.Descriptor)
+        return self._descriptor_wrapper
+    
+    @descriptor.setter
+    def descriptor(self, value: DataDescriptorVal) -> None:
+        """Set the Descriptor field to a wrapper."""
+        self._proto_message.Descriptor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_descriptor_wrapper'):
+            self._descriptor_wrapper._proto_message.CopyFrom(self._proto_message.Descriptor)
+
+
+    @property
+    def format(self) -> DataFormatterVal:
+        """Get the Format field as a wrapper."""
+        if not hasattr(self, '_format_wrapper'):
+            self._format_wrapper = DataFormatterVal(proto_message=self._proto_message.Format)
+        return self._format_wrapper
+    
+    @format.setter
+    def format(self, value: DataFormatterVal) -> None:
+        """Set the Format field to a wrapper."""
+        self._proto_message.Format.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_format_wrapper'):
+            self._format_wrapper._proto_message.CopyFrom(self._proto_message.Format)
+
+
+    # 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})"