DipsScripting 9.1.0__py3-none-any.whl

dips/KinematicAnalysisSettingsVal.py

@@ -0,0 +1,140 @@
+"""Generated wrapper for KinematicAnalysisSettings protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .AngleDataVal import AngleDataVal
+
+class KinematicAnalysisSettingsVal:
+    """Simple wrapper for KinematicAnalysisSettings with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.KinematicAnalysisSettings
+
+
+    def __init__(self, slope_dip: Optional[AngleDataVal] = None, slope_dip_direction: Optional[AngleDataVal] = None, friction_angle: Optional[AngleDataVal] = None, lateral_limits: Optional[AngleDataVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the KinematicAnalysisSettings wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if slope_dip is not None:
+            self._proto_message.SlopeDip.CopyFrom(slope_dip.to_proto())
+            self._slope_dip_wrapper = slope_dip
+        if slope_dip_direction is not None:
+            self._proto_message.SlopeDipDirection.CopyFrom(slope_dip_direction.to_proto())
+            self._slope_dip_direction_wrapper = slope_dip_direction
+        if friction_angle is not None:
+            self._proto_message.FrictionAngle.CopyFrom(friction_angle.to_proto())
+            self._friction_angle_wrapper = friction_angle
+        if lateral_limits is not None:
+            self._proto_message.LateralLimits.CopyFrom(lateral_limits.to_proto())
+            self._lateral_limits_wrapper = lateral_limits
+
+
+    # Properties
+
+    @property
+    def failure_mode_option(self) -> Any:
+        """Get the FailureModeOption field value."""
+        return self._proto_message.FailureModeOption
+    
+    @failure_mode_option.setter
+    def failure_mode_option(self, value: Any) -> None:
+        """Set the FailureModeOption field value."""
+        self._proto_message.FailureModeOption = value
+
+
+    @property
+    def slope_dip(self) -> AngleDataVal:
+        """Get the SlopeDip field as a wrapper."""
+        if not hasattr(self, '_slope_dip_wrapper'):
+            self._slope_dip_wrapper = AngleDataVal(proto_message=self._proto_message.SlopeDip)
+        return self._slope_dip_wrapper
+    
+    @slope_dip.setter
+    def slope_dip(self, value: AngleDataVal) -> None:
+        """Set the SlopeDip field to a wrapper."""
+        self._proto_message.SlopeDip.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_slope_dip_wrapper'):
+            self._slope_dip_wrapper._proto_message.CopyFrom(self._proto_message.SlopeDip)
+
+
+    @property
+    def slope_dip_direction(self) -> AngleDataVal:
+        """Get the SlopeDipDirection field as a wrapper."""
+        if not hasattr(self, '_slope_dip_direction_wrapper'):
+            self._slope_dip_direction_wrapper = AngleDataVal(proto_message=self._proto_message.SlopeDipDirection)
+        return self._slope_dip_direction_wrapper
+    
+    @slope_dip_direction.setter
+    def slope_dip_direction(self, value: AngleDataVal) -> None:
+        """Set the SlopeDipDirection field to a wrapper."""
+        self._proto_message.SlopeDipDirection.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_slope_dip_direction_wrapper'):
+            self._slope_dip_direction_wrapper._proto_message.CopyFrom(self._proto_message.SlopeDipDirection)
+
+
+    @property
+    def friction_angle(self) -> AngleDataVal:
+        """Get the FrictionAngle field as a wrapper."""
+        if not hasattr(self, '_friction_angle_wrapper'):
+            self._friction_angle_wrapper = AngleDataVal(proto_message=self._proto_message.FrictionAngle)
+        return self._friction_angle_wrapper
+    
+    @friction_angle.setter
+    def friction_angle(self, value: AngleDataVal) -> None:
+        """Set the FrictionAngle field to a wrapper."""
+        self._proto_message.FrictionAngle.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_friction_angle_wrapper'):
+            self._friction_angle_wrapper._proto_message.CopyFrom(self._proto_message.FrictionAngle)
+
+
+    @property
+    def lateral_limits(self) -> AngleDataVal:
+        """Get the LateralLimits field as a wrapper."""
+        if not hasattr(self, '_lateral_limits_wrapper'):
+            self._lateral_limits_wrapper = AngleDataVal(proto_message=self._proto_message.LateralLimits)
+        return self._lateral_limits_wrapper
+    
+    @lateral_limits.setter
+    def lateral_limits(self, value: AngleDataVal) -> None:
+        """Set the LateralLimits field to a wrapper."""
+        self._proto_message.LateralLimits.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_lateral_limits_wrapper'):
+            self._lateral_limits_wrapper._proto_message.CopyFrom(self._proto_message.LateralLimits)
+
+
+    # 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/LatLongVal.py

@@ -0,0 +1,84 @@
+"""Generated wrapper for LatLong protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+class LatLongVal:
+    """Simple wrapper for LatLong with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.LatLong
+
+
+    def __init__(self, proto_message: Optional[Any] = None):
+        """Initialize the LatLong 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 longitude(self) -> float:
+        """Get the Longitude field value."""
+        return self._proto_message.Longitude
+    
+    @longitude.setter
+    def longitude(self, value: float) -> None:
+        """Set the Longitude field value."""
+        self._proto_message.Longitude = value
+
+
+    @property
+    def latitude(self) -> float:
+        """Get the Latitude field value."""
+        return self._proto_message.Latitude
+    
+    @latitude.setter
+    def latitude(self, value: float) -> None:
+        """Set the Latitude field value."""
+        self._proto_message.Latitude = value
+
+
+    @property
+    def elevation(self) -> float:
+        """Get the Elevation field value."""
+        return self._proto_message.Elevation
+    
+    @elevation.setter
+    def elevation(self, value: float) -> None:
+        """Set the Elevation field value."""
+        self._proto_message.Elevation = 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/LengthDataVal.py

@@ -0,0 +1,83 @@
+"""Generated wrapper for LengthData protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .DataFormatterVal import DataFormatterVal
+
+class LengthDataVal:
+    """Simple wrapper for LengthData with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.LengthData
+
+
+    def __init__(self, length_unit: Optional[DataFormatterVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the LengthData wrapper."""
+        # Initialize the protobuf message
+        if proto_message is not None:
+            self._proto_message = proto_message
+        else:
+            self._proto_message = self._proto_class()
+
+        if length_unit is not None:
+            self._proto_message.LengthUnit.CopyFrom(length_unit.to_proto())
+            self._length_unit_wrapper = length_unit
+
+
+    # Properties
+
+    @property
+    def length(self) -> float:
+        """Get the Length field value."""
+        return self._proto_message.Length
+    
+    @length.setter
+    def length(self, value: float) -> None:
+        """Set the Length field value."""
+        self._proto_message.Length = value
+
+
+    @property
+    def length_unit(self) -> DataFormatterVal:
+        """Get the LengthUnit field as a wrapper."""
+        if not hasattr(self, '_length_unit_wrapper'):
+            self._length_unit_wrapper = DataFormatterVal(proto_message=self._proto_message.LengthUnit)
+        return self._length_unit_wrapper
+    
+    @length_unit.setter
+    def length_unit(self, value: DataFormatterVal) -> None:
+        """Set the LengthUnit field to a wrapper."""
+        self._proto_message.LengthUnit.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_length_unit_wrapper'):
+            self._length_unit_wrapper._proto_message.CopyFrom(self._proto_message.LengthUnit)
+
+
+    # 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/LineFormatVal.py

@@ -0,0 +1,83 @@
+"""Generated wrapper for LineFormat protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+
+class LineFormatVal:
+    """Simple wrapper for LineFormat with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.LineFormat
+
+
+    def __init__(self, line_color: Optional[ColorSurrogateVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the LineFormat 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_color is not None:
+            self._proto_message.LineColor.CopyFrom(line_color.to_proto())
+            self._line_color_wrapper = line_color
+
+
+    # Properties
+
+    @property
+    def line_color(self) -> ColorSurrogateVal:
+        """Get the LineColor field as a wrapper."""
+        if not hasattr(self, '_line_color_wrapper'):
+            self._line_color_wrapper = ColorSurrogateVal(proto_message=self._proto_message.LineColor)
+        return self._line_color_wrapper
+    
+    @line_color.setter
+    def line_color(self, value: ColorSurrogateVal) -> None:
+        """Set the LineColor field to a wrapper."""
+        self._proto_message.LineColor.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_line_color_wrapper'):
+            self._line_color_wrapper._proto_message.CopyFrom(self._proto_message.LineColor)
+
+
+    @property
+    def line_width(self) -> int:
+        """Get the LineWidth field value."""
+        return self._proto_message.LineWidth
+    
+    @line_width.setter
+    def line_width(self, value: int) -> None:
+        """Set the LineWidth field value."""
+        self._proto_message.LineWidth = 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/LineIntersectionCalculatorToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .LineIntersectionCalculatorToolEntityInfoVal import LineIntersectionCalculatorToolEntityInfoVal
+from .LineIntersectionCalculatorToolEntityInfoVal import LineIntersectionCalculatorToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class LineIntersectionCalculatorToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_LineIntersectionCalculatorToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> LineIntersectionCalculatorToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.LineIntersectionCalculatorToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return LineIntersectionCalculatorToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveLineIntersectionCalculatorTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_LineIntersectionCalculatorToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveLineIntersectionCalculatorTool(functionParam)
+        
+
+    def SetLineIntersectionCalculatorToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_LineIntersectionCalculatorToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetLineIntersectionCalculatorToolVisibility(functionParam)
+        
+
+    def UpdateLineIntersectionCalculatorTool(self,  LineIntersectionCalculatorToolEntityInfo: LineIntersectionCalculatorToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_LineIntersectionCalculatorToolEntityInfo_LineIntersectionCalculatorToolEntityInfo(This=self.__modelRef,  Input1=(LineIntersectionCalculatorToolEntityInfo.to_proto() if hasattr(LineIntersectionCalculatorToolEntityInfo, 'to_proto') else LineIntersectionCalculatorToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateLineIntersectionCalculatorTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+ 

dips/LineIntersectionCalculatorToolEntityInfoVal.py

@@ -0,0 +1,133 @@
+"""Generated wrapper for LineIntersectionCalculatorToolEntityInfo protobuf message."""
+
+from typing import Any, Optional, List, Dict
+from . import DipsAPI_pb2
+
+from .ProtobufCollectionWrappers import _ProtobufListWrapper, _ProtobufMapWrapper
+
+from .ColorSurrogateVal import ColorSurrogateVal
+from .TrendPlungeVal import TrendPlungeVal
+
+class LineIntersectionCalculatorToolEntityInfoVal:
+    """Simple wrapper for LineIntersectionCalculatorToolEntityInfo with Pythonic getters and setters."""
+
+    _proto_class = DipsAPI_pb2.LineIntersectionCalculatorToolEntityInfo
+
+
+    def __init__(self, color: Optional[ColorSurrogateVal] = None, pole1: Optional[TrendPlungeVal] = None, pole2: Optional[TrendPlungeVal] = None, proto_message: Optional[Any] = None):
+        """Initialize the LineIntersectionCalculatorToolEntityInfo 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 pole1 is not None:
+            self._proto_message.Pole1.CopyFrom(pole1.to_proto())
+            self._pole1_wrapper = pole1
+        if pole2 is not None:
+            self._proto_message.Pole2.CopyFrom(pole2.to_proto())
+            self._pole2_wrapper = pole2
+
+
+    # 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 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 pole1(self) -> TrendPlungeVal:
+        """Get the Pole1 field as a wrapper."""
+        if not hasattr(self, '_pole1_wrapper'):
+            self._pole1_wrapper = TrendPlungeVal(proto_message=self._proto_message.Pole1)
+        return self._pole1_wrapper
+    
+    @pole1.setter
+    def pole1(self, value: TrendPlungeVal) -> None:
+        """Set the Pole1 field to a wrapper."""
+        self._proto_message.Pole1.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_pole1_wrapper'):
+            self._pole1_wrapper._proto_message.CopyFrom(self._proto_message.Pole1)
+
+
+    @property
+    def pole2(self) -> TrendPlungeVal:
+        """Get the Pole2 field as a wrapper."""
+        if not hasattr(self, '_pole2_wrapper'):
+            self._pole2_wrapper = TrendPlungeVal(proto_message=self._proto_message.Pole2)
+        return self._pole2_wrapper
+    
+    @pole2.setter
+    def pole2(self, value: TrendPlungeVal) -> None:
+        """Set the Pole2 field to a wrapper."""
+        self._proto_message.Pole2.CopyFrom(value.to_proto())
+        # Update the cached wrapper if it exists
+        if hasattr(self, '_pole2_wrapper'):
+            self._pole2_wrapper._proto_message.CopyFrom(self._proto_message.Pole2)
+
+
+    # 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/LineToolEntityInfoRef.py

@@ -0,0 +1,43 @@
+from typing import List
+from . import DipsAPI_pb2_grpc
+from . import DipsAPI_pb2
+from .LineToolEntityInfoVal import LineToolEntityInfoVal
+from .LineToolEntityInfoVal import LineToolEntityInfoVal
+from .ValidatableResultVal import ValidatableResultVal
+
+class LineToolEntityInfoRef:
+    def __init__(self, channelToConnectOn, ref: DipsAPI_pb2.ProtoReference_LineToolEntityInfo):
+        self.__modelRef = ref
+        self.__refManagerStub = DipsAPI_pb2_grpc.nSameModuleReferenceAccessorStub(channelToConnectOn)
+        self.__channelToConnectOn = channelToConnectOn
+        self.__EntityServicesStubLocal = DipsAPI_pb2_grpc.EntityServicesStub(channelToConnectOn)
+
+    
+    def GetValue(self) -> LineToolEntityInfoVal:
+        bytes = self.__refManagerStub.GetValue(self.__modelRef.ID)
+        ret = DipsAPI_pb2.LineToolEntityInfo()
+        ret.MergeFromString(bytes.data)
+        return LineToolEntityInfoVal.from_proto(ret)
+    
+    def get_model_ref(self):
+        """Get the underlying model reference for direct protobuf operations."""
+        return self.__modelRef
+    
+    def RemoveLineTool(self):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_LineToolEntityInfo(This=self.__modelRef)
+        ret = self.__EntityServicesStubLocal.RemoveLineTool(functionParam)
+        
+
+    def SetLineToolVisibility(self,  Boolean: bool):
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_LineToolEntityInfo_Boolean(This=self.__modelRef,  Input1=Boolean)
+        ret = self.__EntityServicesStubLocal.SetLineToolVisibility(functionParam)
+        
+
+    def UpdateLineTool(self,  LineToolEntityInfo: LineToolEntityInfoVal) -> ValidatableResultVal:
+        functionParam = DipsAPI_pb2.ProtoMemberFunction_ProtoReference_LineToolEntityInfo_LineToolEntityInfo(This=self.__modelRef,  Input1=(LineToolEntityInfo.to_proto() if hasattr(LineToolEntityInfo, 'to_proto') else LineToolEntityInfo))
+        ret = self.__EntityServicesStubLocal.UpdateLineTool(functionParam)
+        
+        return ValidatableResultVal.from_proto(ret)
+        
+
+