DipsScripting 9.1.0__py3-none-any.whl

dips/PoleEntityOptionsVal.py

@@ -0,0 +1,84 @@
+"""Generated wrapper for PoleEntityOptions protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class PoleEntityOptionsVal:
+    """Simple wrapper for PoleEntityOptions with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.PoleEntityOptions
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the PoleEntityOptions 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 pole_mode(self) -> Any:
+        """Get the PoleMode field value."""
+        return self._proto_message.PoleMode
+    
+    @pole_mode.setter
+    def pole_mode(self, value: Any) -> None:
+        """Set the PoleMode field value."""
+        self._proto_message.PoleMode = value
+
+
+    @property
+    def show_pole_planes(self) -> bool:
+        """Get the ShowPolePlanes field value."""
+        return self._proto_message.ShowPolePlanes
+    
+    @show_pole_planes.setter
+    def show_pole_planes(self, value: bool) -> None:
+        """Set the ShowPolePlanes field value."""
+        self._proto_message.ShowPolePlanes = value
+
+
+    @property
+    def show_pole_vector_lines(self) -> bool:
+        """Get the ShowPoleVectorLines field value."""
+        return self._proto_message.ShowPoleVectorLines
+    
+    @show_pole_vector_lines.setter
+    def show_pole_vector_lines(self, value: bool) -> None:
+        """Set the ShowPoleVectorLines field value."""
+        self._proto_message.ShowPoleVectorLines = 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/PoleEntityVisibilityVal.py

@@ -0,0 +1,83 @@
+"""Generated wrapper for PoleEntityVisibility protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .PoleEntityOptionsVal import PoleEntityOptionsVal
+
+class PoleEntityVisibilityVal:
+    """Simple wrapper for PoleEntityVisibility with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.PoleEntityVisibility
+
+
+    def __init__(self, options: Optional[PoleEntityOptionsVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the PoleEntityVisibility wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if options is not None:
+            self._proto_message.Options.CopyFrom(options.to_proto())
+            self._options_wrapper = 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 options(self) -> PoleEntityOptionsVal:
+        """Get the Options field as a wrapper."""
+        if not hasattr(self, '_options_wrapper'):
+            self._options_wrapper = PoleEntityOptionsVal(proto_message=self._proto_message.Options)
+        return self._options_wrapper
+    
+    @options.setter
+    def options(self, value: PoleEntityOptionsVal) -> 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)
+
+
+    # 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/PolygonToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .PolygonToolEntityInfoVal import PolygonToolEntityInfoVal
+from .PolygonToolEntityInfoVal import PolygonToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class PolygonToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_PolygonToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> PolygonToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.PolygonToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return PolygonToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemovePolygonTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_PolygonToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemovePolygonTool(functionParam)
+        
+
+    def SetPolygonToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_PolygonToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetPolygonToolVisibility(functionParam)
+        
+
+    def UpdatePolygonTool(self,  PolygonToolEntityInfo: PolygonToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_PolygonToolEntityInfo_PolygonToolEntityInfo(This=self.__modelRef,  Input1=(PolygonToolEntityInfo.to_proto() if hasattr(PolygonToolEntityInfo, 'to_proto') else PolygonToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdatePolygonTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/PolygonToolEntityInfoVal.py

@@ -0,0 +1,131 @@
+"""Generated wrapper for PolygonToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .FillFormatVal import FillFormatVal
+from .LineFormatVal import LineFormatVal
+from .Vector2DVal import Vector2DVal
+
+class PolygonToolEntityInfoVal:
+    """Simple wrapper for PolygonToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.PolygonToolEntityInfo
+
+
+    def __init__(self, line_format: Optional[LineFormatVal] = None, fill_format: Optional[FillFormatVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the PolygonToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if line_format is not None:
+            self._proto_message.LineFormat.CopyFrom(line_format.to_proto())
+            self._line_format_wrapper = line_format
+        if fill_format is not None:
+            self._proto_message.FillFormat.CopyFrom(fill_format.to_proto())
+            self._fill_format_wrapper = fill_format
+
+
+    # Properties
+
+    @property
+    def is_visible(self) -> bool:
+        """Get the IsVisible field value."""
+        return self._proto_message.IsVisible
+    
+    @is_visible.setter
+    def is_visible(self, value: bool) -> None:
+        """Set the IsVisible field value."""
+        self._proto_message.IsVisible = value
+
+
+    @property
+    def name(self) -> str:
+        """Get the Name field value."""
+        return self._proto_message.Name
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        """Set the Name field value."""
+        self._proto_message.Name = value
+
+
+    @property
+    def line_format(self) -> LineFormatVal:
+        """Get the LineFormat field as a wrapper."""
+        if not hasattr(self, '_line_format_wrapper'):
+            self._line_format_wrapper = LineFormatVal(proto_message=self._proto_message.LineFormat)
+        return self._line_format_wrapper
+    
+    @line_format.setter
+    def line_format(self, value: LineFormatVal) -> None:
+        """Set the LineFormat field to a wrapper."""
+        self._proto_message.LineFormat.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_line_format_wrapper'):
+            self._line_format_wrapper._proto_message.CopyFrom(self._proto_message.LineFormat)
+
+
+    @property
+    def fill_format(self) -> FillFormatVal:
+        """Get the FillFormat field as a wrapper."""
+        if not hasattr(self, '_fill_format_wrapper'):
+            self._fill_format_wrapper = FillFormatVal(proto_message=self._proto_message.FillFormat)
+        return self._fill_format_wrapper
+    
+    @fill_format.setter
+    def fill_format(self, value: FillFormatVal) -> None:
+        """Set the FillFormat field to a wrapper."""
+        self._proto_message.FillFormat.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_fill_format_wrapper'):
+            self._fill_format_wrapper._proto_message.CopyFrom(self._proto_message.FillFormat)
+
+
+    @property
+    def points(self) -> List[Vector2DVal]:
+        """Get the Points field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Points, Vector2DVal)
+    
+    @points.setter
+    def points(self, value: List[Vector2DVal]) -> None:
+        """Set the Points 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.Points[:] = []
+        for item in value:
+            self._proto_message.Points.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})"

dips/PolylineToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .PolylineToolEntityInfoVal import PolylineToolEntityInfoVal
+from .PolylineToolEntityInfoVal import PolylineToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class PolylineToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_PolylineToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> PolylineToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.PolylineToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return PolylineToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemovePolylineTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_PolylineToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemovePolylineTool(functionParam)
+        
+
+    def SetPolylineToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_PolylineToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetPolylineToolVisibility(functionParam)
+        
+
+    def UpdatePolylineTool(self,  PolylineToolEntityInfo: PolylineToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_PolylineToolEntityInfo_PolylineToolEntityInfo(This=self.__modelRef,  Input1=(PolylineToolEntityInfo.to_proto() if hasattr(PolylineToolEntityInfo, 'to_proto') else PolylineToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdatePolylineTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/PolylineToolEntityInfoVal.py

@@ -0,0 +1,111 @@
+"""Generated wrapper for PolylineToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .LineFormatVal import LineFormatVal
+from .Vector2DVal import Vector2DVal
+
+class PolylineToolEntityInfoVal:
+    """Simple wrapper for PolylineToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.PolylineToolEntityInfo
+
+
+    def __init__(self, line_format: Optional[LineFormatVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the PolylineToolEntityInfo wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if line_format is not None:
+            self._proto_message.LineFormat.CopyFrom(line_format.to_proto())
+            self._line_format_wrapper = line_format
+
+
+    # Properties
+
+    @property
+    def is_visible(self) -> bool:
+        """Get the IsVisible field value."""
+        return self._proto_message.IsVisible
+    
+    @is_visible.setter
+    def is_visible(self, value: bool) -> None:
+        """Set the IsVisible field value."""
+        self._proto_message.IsVisible = value
+
+
+    @property
+    def name(self) -> str:
+        """Get the Name field value."""
+        return self._proto_message.Name
+    
+    @name.setter
+    def name(self, value: str) -> None:
+        """Set the Name field value."""
+        self._proto_message.Name = value
+
+
+    @property
+    def line_format(self) -> LineFormatVal:
+        """Get the LineFormat field as a wrapper."""
+        if not hasattr(self, '_line_format_wrapper'):
+            self._line_format_wrapper = LineFormatVal(proto_message=self._proto_message.LineFormat)
+        return self._line_format_wrapper
+    
+    @line_format.setter
+    def line_format(self, value: LineFormatVal) -> None:
+        """Set the LineFormat field to a wrapper."""
+        self._proto_message.LineFormat.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_line_format_wrapper'):
+            self._line_format_wrapper._proto_message.CopyFrom(self._proto_message.LineFormat)
+
+
+    @property
+    def points(self) -> List[Vector2DVal]:
+        """Get the Points field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.Points, Vector2DVal)
+    
+    @points.setter
+    def points(self, value: List[Vector2DVal]) -> None:
+        """Set the Points 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.Points[:] = []
+        for item in value:
+            self._proto_message.Points.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})"

dips/ProcessedDataVal.py

@@ -0,0 +1,94 @@
+"""Generated wrapper for ProcessedData protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .TrendPlungeVal import TrendPlungeVal
+
+class ProcessedDataVal:
+    """Simple wrapper for ProcessedData with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.ProcessedData
+
+
+    def __init__(self, orientation: Optional[TrendPlungeVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the ProcessedData wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if orientation is not None:
+            self._proto_message.Orientation.CopyFrom(orientation.to_proto())
+            self._orientation_wrapper = orientation
+
+
+    # Properties
+
+    @property
+    def orientation(self) -> TrendPlungeVal:
+        """Get the Orientation field as a wrapper."""
+        if not hasattr(self, '_orientation_wrapper'):
+            self._orientation_wrapper = TrendPlungeVal(proto_message=self._proto_message.Orientation)
+        return self._orientation_wrapper
+    
+    @orientation.setter
+    def orientation(self, value: TrendPlungeVal) -> None:
+        """Set the Orientation field to a wrapper."""
+        self._proto_message.Orientation.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_orientation_wrapper'):
+            self._orientation_wrapper._proto_message.CopyFrom(self._proto_message.Orientation)
+
+
+    @property
+    def weight(self) -> float:
+        """Get the Weight field value."""
+        return self._proto_message.Weight
+    
+    @weight.setter
+    def weight(self, value: float) -> None:
+        """Set the Weight field value."""
+        self._proto_message.Weight = value
+
+
+    @property
+    def quantity(self) -> float:
+        """Get the Quantity field value."""
+        return self._proto_message.Quantity
+    
+    @quantity.setter
+    def quantity(self, value: float) -> None:
+        """Set the Quantity field value."""
+        self._proto_message.Quantity = value
+
+
+    # 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})"