DipsScripting 9.1.0__py3-none-any.whl

dips/AnchorPointVal.py

@@ -0,0 +1,103 @@
+"""Generated wrapper for AnchorPoint protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .TrendPlungeVal import TrendPlungeVal
+from .Vector2DVal import Vector2DVal
+
+class AnchorPointVal:
+    """Simple wrapper for AnchorPoint with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.AnchorPoint
+
+
+    def __init__(self, spherical_point: Optional[TrendPlungeVal] = None, logical_point: Optional[Vector2DVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the AnchorPoint wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if spherical_point is not None:
+            self._proto_message.SphericalPoint.CopyFrom(spherical_point.to_proto())
+            self._spherical_point_wrapper = spherical_point
+        if logical_point is not None:
+            self._proto_message.LogicalPoint.CopyFrom(logical_point.to_proto())
+            self._logical_point_wrapper = logical_point
+
+
+    # Properties
+
+    @property
+    def coordinate_option(self) -> Any:
+        """Get the CoordinateOption field value."""
+        return self._proto_message.CoordinateOption
+    
+    @coordinate_option.setter
+    def coordinate_option(self, value: Any) -> None:
+        """Set the CoordinateOption field value."""
+        self._proto_message.CoordinateOption = value
+
+
+    @property
+    def spherical_point(self) -> TrendPlungeVal:
+        """Get the SphericalPoint field as a wrapper."""
+        if not hasattr(self, '_spherical_point_wrapper'):
+            self._spherical_point_wrapper = TrendPlungeVal(proto_message=self._proto_message.SphericalPoint)
+        return self._spherical_point_wrapper
+    
+    @spherical_point.setter
+    def spherical_point(self, value: TrendPlungeVal) -> None:
+        """Set the SphericalPoint field to a wrapper."""
+        self._proto_message.SphericalPoint.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_spherical_point_wrapper'):
+            self._spherical_point_wrapper._proto_message.CopyFrom(self._proto_message.SphericalPoint)
+
+
+    @property
+    def logical_point(self) -> Vector2DVal:
+        """Get the LogicalPoint field as a wrapper."""
+        if not hasattr(self, '_logical_point_wrapper'):
+            self._logical_point_wrapper = Vector2DVal(proto_message=self._proto_message.LogicalPoint)
+        return self._logical_point_wrapper
+    
+    @logical_point.setter
+    def logical_point(self, value: Vector2DVal) -> None:
+        """Set the LogicalPoint field to a wrapper."""
+        self._proto_message.LogicalPoint.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_logical_point_wrapper'):
+            self._logical_point_wrapper._proto_message.CopyFrom(self._proto_message.LogicalPoint)
+
+
+    # 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/AngleDataVal.py

@@ -0,0 +1,62 @@
+"""Generated wrapper for AngleData protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class AngleDataVal:
+    """Simple wrapper for AngleData with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.AngleData
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the AngleData 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 angle_radians(self) -> float:
+        """Get the AngleRadians field value."""
+        return self._proto_message.AngleRadians
+    
+    @angle_radians.setter
+    def angle_radians(self, value: float) -> None:
+        """Set the AngleRadians field value."""
+        self._proto_message.AngleRadians = 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/AnnotativeTools2DVal.py

@@ -0,0 +1,273 @@
+"""Generated wrapper for AnnotativeTools2D protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ArrowToolEntityInfoVal import ArrowToolEntityInfoVal
+from .ConeToolEntityInfoVal import ConeToolEntityInfoVal
+from .EllipseToolEntityInfoVal import EllipseToolEntityInfoVal
+from .LineIntersectionCalculatorToolEntityInfoVal import LineIntersectionCalculatorToolEntityInfoVal
+from .LineToolEntityInfoVal import LineToolEntityInfoVal
+from .MeasureAngleToolEntityInfoVal import MeasureAngleToolEntityInfoVal
+from .PitchGridToolEntityInfoVal import PitchGridToolEntityInfoVal
+from .PlaneIntersectionCalculatorToolEntityInfoVal import PlaneIntersectionCalculatorToolEntityInfoVal
+from .PolygonToolEntityInfoVal import PolygonToolEntityInfoVal
+from .PolylineToolEntityInfoVal import PolylineToolEntityInfoVal
+from .RectangleToolEntityInfoVal import RectangleToolEntityInfoVal
+from .TextToolEntityInfoVal import TextToolEntityInfoVal
+from .TrendLineToolEntityInfoVal import TrendLineToolEntityInfoVal
+
+class AnnotativeTools2DVal:
+    """Simple wrapper for AnnotativeTools2D with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.AnnotativeTools2D
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the AnnotativeTools2D 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 text_tool_entities(self) -> List[TextToolEntityInfoVal]:
+        """Get the TextToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.TextToolEntities, TextToolEntityInfoVal)
+    
+    @text_tool_entities.setter
+    def text_tool_entities(self, value: List[TextToolEntityInfoVal]) -> None:
+        """Set the TextToolEntities 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.TextToolEntities[:] = []
+        for item in value:
+            self._proto_message.TextToolEntities.append(item.to_proto())
+
+
+    @property
+    def arrow_tool_entities(self) -> List[ArrowToolEntityInfoVal]:
+        """Get the ArrowToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.ArrowToolEntities, ArrowToolEntityInfoVal)
+    
+    @arrow_tool_entities.setter
+    def arrow_tool_entities(self, value: List[ArrowToolEntityInfoVal]) -> None:
+        """Set the ArrowToolEntities 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.ArrowToolEntities[:] = []
+        for item in value:
+            self._proto_message.ArrowToolEntities.append(item.to_proto())
+
+
+    @property
+    def line_tool_entities(self) -> List[LineToolEntityInfoVal]:
+        """Get the LineToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.LineToolEntities, LineToolEntityInfoVal)
+    
+    @line_tool_entities.setter
+    def line_tool_entities(self, value: List[LineToolEntityInfoVal]) -> None:
+        """Set the LineToolEntities 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.LineToolEntities[:] = []
+        for item in value:
+            self._proto_message.LineToolEntities.append(item.to_proto())
+
+
+    @property
+    def polyline_tool_entities(self) -> List[PolylineToolEntityInfoVal]:
+        """Get the PolylineToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.PolylineToolEntities, PolylineToolEntityInfoVal)
+    
+    @polyline_tool_entities.setter
+    def polyline_tool_entities(self, value: List[PolylineToolEntityInfoVal]) -> None:
+        """Set the PolylineToolEntities 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.PolylineToolEntities[:] = []
+        for item in value:
+            self._proto_message.PolylineToolEntities.append(item.to_proto())
+
+
+    @property
+    def polygon_tool_entities(self) -> List[PolygonToolEntityInfoVal]:
+        """Get the PolygonToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.PolygonToolEntities, PolygonToolEntityInfoVal)
+    
+    @polygon_tool_entities.setter
+    def polygon_tool_entities(self, value: List[PolygonToolEntityInfoVal]) -> None:
+        """Set the PolygonToolEntities 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.PolygonToolEntities[:] = []
+        for item in value:
+            self._proto_message.PolygonToolEntities.append(item.to_proto())
+
+
+    @property
+    def rectangle_tool_entities(self) -> List[RectangleToolEntityInfoVal]:
+        """Get the RectangleToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.RectangleToolEntities, RectangleToolEntityInfoVal)
+    
+    @rectangle_tool_entities.setter
+    def rectangle_tool_entities(self, value: List[RectangleToolEntityInfoVal]) -> None:
+        """Set the RectangleToolEntities 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.RectangleToolEntities[:] = []
+        for item in value:
+            self._proto_message.RectangleToolEntities.append(item.to_proto())
+
+
+    @property
+    def ellipse_tool_entities(self) -> List[EllipseToolEntityInfoVal]:
+        """Get the EllipseToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.EllipseToolEntities, EllipseToolEntityInfoVal)
+    
+    @ellipse_tool_entities.setter
+    def ellipse_tool_entities(self, value: List[EllipseToolEntityInfoVal]) -> None:
+        """Set the EllipseToolEntities 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.EllipseToolEntities[:] = []
+        for item in value:
+            self._proto_message.EllipseToolEntities.append(item.to_proto())
+
+
+    @property
+    def trend_line_tool_entities(self) -> List[TrendLineToolEntityInfoVal]:
+        """Get the TrendLineToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.TrendLineToolEntities, TrendLineToolEntityInfoVal)
+    
+    @trend_line_tool_entities.setter
+    def trend_line_tool_entities(self, value: List[TrendLineToolEntityInfoVal]) -> None:
+        """Set the TrendLineToolEntities 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.TrendLineToolEntities[:] = []
+        for item in value:
+            self._proto_message.TrendLineToolEntities.append(item.to_proto())
+
+
+    @property
+    def cone_tool_entities(self) -> List[ConeToolEntityInfoVal]:
+        """Get the ConeToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.ConeToolEntities, ConeToolEntityInfoVal)
+    
+    @cone_tool_entities.setter
+    def cone_tool_entities(self, value: List[ConeToolEntityInfoVal]) -> None:
+        """Set the ConeToolEntities 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.ConeToolEntities[:] = []
+        for item in value:
+            self._proto_message.ConeToolEntities.append(item.to_proto())
+
+
+    @property
+    def pitch_grid_tool_entities(self) -> List[PitchGridToolEntityInfoVal]:
+        """Get the PitchGridToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.PitchGridToolEntities, PitchGridToolEntityInfoVal)
+    
+    @pitch_grid_tool_entities.setter
+    def pitch_grid_tool_entities(self, value: List[PitchGridToolEntityInfoVal]) -> None:
+        """Set the PitchGridToolEntities 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.PitchGridToolEntities[:] = []
+        for item in value:
+            self._proto_message.PitchGridToolEntities.append(item.to_proto())
+
+
+    @property
+    def measure_angle_tool_entities(self) -> List[MeasureAngleToolEntityInfoVal]:
+        """Get the MeasureAngleToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.MeasureAngleToolEntities, MeasureAngleToolEntityInfoVal)
+    
+    @measure_angle_tool_entities.setter
+    def measure_angle_tool_entities(self, value: List[MeasureAngleToolEntityInfoVal]) -> None:
+        """Set the MeasureAngleToolEntities 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.MeasureAngleToolEntities[:] = []
+        for item in value:
+            self._proto_message.MeasureAngleToolEntities.append(item.to_proto())
+
+
+    @property
+    def line_intersection_calculator_tool_entities(self) -> List[LineIntersectionCalculatorToolEntityInfoVal]:
+        """Get the LineIntersectionCalculatorToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.LineIntersectionCalculatorToolEntities, LineIntersectionCalculatorToolEntityInfoVal)
+    
+    @line_intersection_calculator_tool_entities.setter
+    def line_intersection_calculator_tool_entities(self, value: List[LineIntersectionCalculatorToolEntityInfoVal]) -> None:
+        """Set the LineIntersectionCalculatorToolEntities 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.LineIntersectionCalculatorToolEntities[:] = []
+        for item in value:
+            self._proto_message.LineIntersectionCalculatorToolEntities.append(item.to_proto())
+
+
+    @property
+    def plane_intersection_calculator_tool_entities(self) -> List[PlaneIntersectionCalculatorToolEntityInfoVal]:
+        """Get the PlaneIntersectionCalculatorToolEntities field as a list of wrappers."""
+        return _ProtobufListWrapper(self._proto_message.PlaneIntersectionCalculatorToolEntities, PlaneIntersectionCalculatorToolEntityInfoVal)
+    
+    @plane_intersection_calculator_tool_entities.setter
+    def plane_intersection_calculator_tool_entities(self, value: List[PlaneIntersectionCalculatorToolEntityInfoVal]) -> None:
+        """Set the PlaneIntersectionCalculatorToolEntities 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.PlaneIntersectionCalculatorToolEntities[:] = []
+        for item in value:
+            self._proto_message.PlaneIntersectionCalculatorToolEntities.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/ApplicationManager.py

@@ -0,0 +1,89 @@
+import subprocess
+import time
+from multiprocessing.connection import Listener
+from logging import Logger
+
+class ApplicationManager:
+    minimumPort = 49152
+    maximumPort = 65535
+    defaultTimeout = 120
+    def startApplication(self, pathToExecutable : str, port : int, isServerRunning : callable, logger : Logger, timeout : float = defaultTimeout, headless : bool = False, fileToOpen : str = None):
+        """
+        Starts the application specified by pathToExecutable and starts the python server on the given port. 
+        Returns when the server is ready to accept requests.
+        Throws TimeoutError exception if the server is not ready within that time.
+
+        Args:
+            pathToExecutable: the full path to the executable of the application you want to start.
+            port: the port number you want the python server to bind to.
+            isServerRunning: a callable that returns True if the server is ready to accept requests.
+            logger: a logger object. It will be disabled while trying to connect to the server.
+            timeout: time in seconds before we stop trying to start the application
+        
+        Raises:
+        	ValueError: Port range must be between 49152 and 65535, otherwise ValueError is raised
+		    TimeoutError: if timeout is provided, raises TimeoutError if not able to connect to the server within that time.
+        """
+        if port < self.minimumPort or port > self.maximumPort:
+            msg = f"port must be in the range {self.minimumPort} to {self.maximumPort}"
+            logger.error(msg)
+            raise ValueError(msg)
+        
+        if not self._isPortAvailable(port):
+            msg = f"port number {port} is occupied. Please choose another port."
+            logger.error(msg)
+            raise RuntimeError(msg)
+
+        logger.info(f"Attempting to start the application at {pathToExecutable} and binding server to port {port}...")
+        pathAndArgs = [f"{pathToExecutable}", "--startScriptingServer", f"{port}"]
+        if(headless):
+            pathAndArgs.append("-headless")
+        if(fileToOpen is not None):
+            pathAndArgs.append("--filename")
+            pathAndArgs.append(fileToOpen)
+
+        SW_MINIMIZE = 6
+        info = subprocess.STARTUPINFO()
+        info.dwFlags = subprocess.STARTF_USESHOWWINDOW
+        info.wShowWindow = SW_MINIMIZE
+
+        subprocess.Popen(pathAndArgs, start_new_session = True, creationflags=subprocess.DETACHED_PROCESS, startupinfo=info)
+
+        self._tryToConnectToServer(port, isServerRunning, timeout, logger)
+       
+
+    def _isPortAvailable(self, port):
+        portAvailable = False
+        listener = None
+        try:
+            listener = Listener(('localhost', port), 'AF_INET')
+            portAvailable = True
+        except Exception:
+            portAvailable = False
+        
+        if listener:
+            listener.close()
+
+        return portAvailable
+
+    def _tryToConnectToServer(self, port : int, isServerRunning : callable, timeout, logger : Logger):
+
+        startTime = time.time()
+        serverIsRunning = False
+
+        while not serverIsRunning:
+            if timeout:
+                if (time.time() - startTime) > timeout:
+                    msg = "The application did not start within the given timeout time."
+                    logger.error(msg)
+                    raise TimeoutError(msg)
+            try:
+                logger.debug("Trying to connect to the server...")
+                logger.disabled = True
+                isServerRunning(port)
+            except Exception as e:
+                continue
+            finally:
+                logger.disabled = False
+            serverIsRunning = True
+            logger.debug("connectied!")

dips/ArrowToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .ArrowToolEntityInfoVal import ArrowToolEntityInfoVal
+from .ArrowToolEntityInfoVal import ArrowToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class ArrowToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_ArrowToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> ArrowToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.ArrowToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return ArrowToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveArrowTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ArrowToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveArrowTool(functionParam)
+        
+
+    def SetArrowToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ArrowToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetArrowToolVisibility(functionParam)
+        
+
+    def UpdateArrowTool(self,  ArrowToolEntityInfo: ArrowToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_ArrowToolEntityInfo_ArrowToolEntityInfo(This=self.__modelRef,  Input1=(ArrowToolEntityInfo.to_proto() if hasattr(ArrowToolEntityInfo, 'to_proto') else ArrowToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateArrowTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+