RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/groundwater/WaterGrid.py

@@ -0,0 +1,120 @@
+import rs3.generatedFiles.WaterPressureGridDataService_pb2_grpc as WaterPressureGridDataService_pb2_grpc
+import rs3.generatedFiles.WaterPressureGridDataService_pb2 as WaterPressureGridDataService_pb2
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+from rs3.properties.PropertyEnums import *
+from ._PropertyAccessor import WaterGridPropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.ColorPicker import ColorPicker
+
+class WaterGridProperty(_ProxyObject):
+    """
+    Edit a pore water pressure defined by locations.
+
+    Examples:
+        See :ref:`water_grid_example`.
+        
+    """
+    def __init__(self, client : Client, waterSurfaceID : str, projectID: str):
+        super().__init__(client, waterSurfaceID)
+        self._waterGridDataService = WaterPressureGridDataService_pb2_grpc.WaterPressureGridDataServiceStub(self._client.channel)
+        self._propertyAccessor = WaterGridPropertyAccessor(client, waterSurfaceID, self._waterGridDataService, projectID)
+        self.projectID = projectID
+
+    def setName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+    def getName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setColor(self, *args):
+        """
+        Sets the RGBA color for the object.
+
+        Raises:
+            ValueError: If inputs are invalid or out of range.
+            
+        Notes:
+            Accepted formats:
+                - setColor(red, green, blue)
+                - setColor(red, green, blue, alpha)
+                - setColor("#RRGGBB")
+                - setColor("#RRGGBBAA")
+                - setColor(ColorType.Rose)
+                - setColor(0xE1E4FF)  # Integer COLORREF
+
+        """
+        color_bytes = ColorPicker._setColorValidation(*args)
+        request = WaterPressureGridDataService_pb2.SetProjectColorRequest(objectId=self._objectId, value=color_bytes, projectId=self.projectID)
+        self._client.callFunction(self._waterGridDataService.SetColorProperty, request)
+    def getColor(self) -> tuple[int, int, int, int]:
+        """
+        Retrieves the RGBA color of the object.
+
+        Returns:
+            tuple[int, int, int, int]: A tuple of four integers representing the red, green, blue, and alpha components of the object's color, each in the range [0, 255].
+        """
+        request = WaterPressureGridDataService_pb2.GetProjectColorRequest(objectId=self._objectId, projectId=self.projectID)
+        response : WaterPressureGridDataService_pb2.GetProjectColorResponse = self._client.callFunction(self._waterGridDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha
+    def setIs3D(self, value: bool):
+        self._propertyAccessor.setBoolValue("Is3D", value)
+    def getIs3D(self) -> bool:
+        return self._propertyAccessor.getBoolValue("Is3D")
+    def set2DPlaneType(self, plane2DType : WaterGridPlane2DType):
+        self._propertyAccessor.setEnumValue("Plane2D_type", plane2DType.value)
+    def get2DPlaneType(self) -> WaterGridPlane2DType:
+        return self._propertyAccessor.getEnumValue("Plane2D_type", WaterGridPlane2DType)
+    def setInterpolationMethod(self, interpolationMethod : WaterGridInterpolationMethodType):
+        self._propertyAccessor.setEnumValue("InterpolationMethod", interpolationMethod.value)
+    def getInterpolationMethod(self) -> WaterGridInterpolationMethodType:
+        return self._propertyAccessor.getEnumValue("InterpolationMethod", WaterGridInterpolationMethodType)
+    def setWaterGridPointSetType(self, type : WaterGridPointSetType):
+        self._propertyAccessor.setEnumValue("Type", type.value)
+    def getWaterGridPointSetType(self) -> WaterGridPointSetType:
+        return self._propertyAccessor.getEnumValue("Type", WaterGridPointSetType)
+    def setWaterGridPoints(self, value: list[tuple[float, float, float, float]]):
+        """
+        Set water grid point values.
+
+        Parameters
+        ----------
+        value : list[tuple[float, float, float, float]]
+            A list of water grid points defined as (x, y, z, value).
+
+            Important:
+            - The coordinates must always be provided as 3D (x, y, z),
+            regardless of whether the water grid is defined as 2D or 3D.
+            - For 2D grids, the unused coordinate must still be supplied
+            (typically set to 0.0).
+
+            The meaning of `value` depends on the water grid point set type:
+            - Pore pressure
+            - Pressure head
+            - Total head
+
+            The interpretation is determined by the configured water grid type.
+        """
+        waterGridlist = []
+        for x, y, z, value in value:
+            waterGridPoint = WaterPressureGridDataService_pb2.WaterGridSet(x=x, y=y, z=z, commonValue=value)
+            waterGridlist.append(waterGridPoint)
+        request = WaterPressureGridDataService_pb2.SetPWPPointSetRequest(waterGridId=self._objectId, PWPPointSet=waterGridlist, projectId=self.projectID)
+        self._client.callFunction(self._waterGridDataService.SetPWPPointSet, request)
+    def getWaterGridPoints(self) -> list[tuple[float, float, float, float]]:
+        """
+        Retrieve water grid point values.
+
+        Returns
+        -------
+        list[tuple[float, float, float, float]]
+            A list of water grid points in the format (x, y, z, value).
+
+            Important:
+            - Coordinates are always returned in 3D format.
+            - The returned `value` represents pore pressure, pressure head,
+            or total head, depending on the water grid point set type.
+
+        """
+        request = WaterPressureGridDataService_pb2.GetPWPPointSetRequest(waterGridId=self._objectId, projectId=self.projectID)
+        response : WaterPressureGridDataService_pb2.GetPWPPointSetResponse = self._client.callFunction(self._waterGridDataService.GetPWPPointSet, request)
+        return list((p.x, p.y, p.z, p.commonValue) for p in response.PWPPointSet)

rs3/properties/groundwater/_PropertyAccessor.py

@@ -0,0 +1,36 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor
+import rs3.generatedFiles.WaterByLocationDataService_pb2 as WaterByLocationDataService_pb2
+import rs3.generatedFiles.WaterPressureGridDataService_pb2 as WaterPressureGridDataService_pb2
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+class WaterByLocationPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str, stub, projectId : str):
+        super().__init__(client, objectId, stub)
+        self.projectId = projectId    
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = WaterByLocationDataService_pb2.SetProjectPropertyRequest(objectId=self.objectId, 
+                                                                                propertyName=propertyName,
+                                                                                value=value,
+                                                                                projectId=self.projectId)
+        self._client.callFunction(self._stub.SetProperty, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = WaterByLocationDataService_pb2.GetProjectPropertyRequest(objectId=self.objectId, propertyName=propertyName, projectId=self.projectId)
+        response : WaterByLocationDataService_pb2.GetProjectPropertyResponse = self._client.callFunction(self._stub.GetProperty, request)
+        return response.value
+    
+class WaterGridPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str, stub, projectId : str):
+        super().__init__(client, objectId, stub)
+        self.projectId = projectId    
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = WaterPressureGridDataService_pb2.SetProjectPropertyRequest(objectId=self.objectId, 
+                                                                                propertyName=propertyName,
+                                                                                value=value,
+                                                                                projectId=self.projectId)
+        self._client.callFunction(self._stub.SetProperty, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = WaterPressureGridDataService_pb2.GetProjectPropertyRequest(objectId=self.objectId, propertyName=propertyName, projectId=self.projectId)
+        response : WaterPressureGridDataService_pb2.GetProjectPropertyResponse = self._client.callFunction(self._stub.GetProperty, request)
+        return response.value

rs3/properties/joint/BartonBandis.py

@@ -0,0 +1,118 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.JointStageFactorService_pb2_grpc as JointStageFactorService_pb2_grpc
+class BartonBandisBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getJCS(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("JCS")
+    def setJCS(self, value: float):
+        self._propertyAccessor.setDoubleProperty("JCS", value)
+    def getJRC(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("JRC")
+    def setJRC(self, value: float):
+        self._propertyAccessor.setDoubleProperty("JRC", value)
+    def getNormalStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("NormalStiffness")
+    def setNormalStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("NormalStiffness", value)
+    def getShearStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ShearStiffness")
+    def setShearStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ShearStiffness", value)
+    def getResidualFrictionAngle(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("FrictionAngleResidual")
+    def setResidualFrictionAngle(self, value: float):
+        self._propertyAccessor.setDoubleProperty("FrictionAngleResidual", value)
+    def getDefineResidualStrength(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasResidualStrength")
+    def setDefineResidualStrength(self, value: bool):
+        self._propertyAccessor.setBoolValue("HasResidualStrength", value)
+    def getProperties(self):
+        return {
+            "JCS": self.getJCS(),
+            "JRC": self.getJRC(),
+            "NormalStiffness": self.getNormalStiffness(),
+            "ShearStiffness": self.getShearStiffness(),
+            "ResidualFrictionAngle": self.getResidualFrictionAngle(),
+            "DefineResidualStrength": self.getDefineResidualStrength(),
+        }
+    def setProperties(self, JCS: float = None, JRC: float = None, NormalStiffness: float = None, ShearStiffness: float = None, ResidualFrictionAngle: float = None, DefineResidualStrength: bool = None):
+        if JCS is not None:
+            self.setJCS(JCS)
+        if JRC is not None:
+            self.setJRC(JRC)
+        if NormalStiffness is not None:
+            self.setNormalStiffness(NormalStiffness)
+        if ShearStiffness is not None:
+            self.setShearStiffness(ShearStiffness)
+        if ResidualFrictionAngle is not None:
+            self.setResidualFrictionAngle(ResidualFrictionAngle)
+        if DefineResidualStrength is not None:
+            self.setDefineResidualStrength(DefineResidualStrength)
+class BartonBandisStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, JointStageFactorService_pb2_grpc.JointStageFactorServiceStub(client.channel))
+    def getResidualFrictionAngleFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("BartonBandis_FrictionAngleResidual")
+    def getJCSFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("BartonBandis_JCSFactor")
+    def getJRCFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("BartonBandis_JRCFactor")
+    def getNormalStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("BartonBandis_NormalStiffness")
+    def getShearStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("BartonBandis_ShearStiffness")
+class BartonBandisDefinedStageFactorBase(BartonBandisStageFactorBase):
+    def setResidualFrictionAngleFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("BartonBandis_FrictionAngleResidual", value)
+    def setJCSFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("BartonBandis_JCSFactor", value)
+    def setJRCFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("BartonBandis_JRCFactor", value)
+    def setNormalStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("BartonBandis_NormalStiffness", value)
+    def setShearStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("BartonBandis_ShearStiffness", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface
+import rs3.generatedFiles.JointService_pb2_grpc as JointService_pb2_grpc
+import rs3.generatedFiles.JointService_pb2 as JointService_pb2
+
+class BartonBandisStageFactor(BartonBandisStageFactorBase):
+    """
+	Examples:
+		See :ref:`joint_example`.
+	"""
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+        
+class BartonBandisDefinedStageFactor(BartonBandisStageFactor, BartonBandisDefinedStageFactorBase):
+    """
+	Examples:
+		See :ref:`joint_example`.
+	"""
+    pass
+
+class BartonBandis(BartonBandisBase):
+    """
+	Examples:
+		See :ref:`joint_example`.
+	"""
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._jointService = JointService_pb2_grpc.JointServiceStub(self._client.channel)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[BartonBandisDefinedStageFactor, BartonBandisStageFactor](id, client, BartonBandisDefinedStageFactor, BartonBandisStageFactor)
+    def getAllowSlipStartFromStage(self) -> int:
+        request = JointService_pb2.GetSlipStageRequest(jointId=self._objectId)
+        respond : JointService_pb2.GetSlipStageResponse = self._client.callFunction(self._jointService.GetSlipStage, request)
+        return respond.slipStageNumber
+    def setAllowSlipStartFromStage(self, value: int):
+        request = JointService_pb2.SetSlipStageRequest(jointId=self._objectId, slipStageNumber=value)
+        self._client.callFunction(self._jointService.SetSlipStage, request)

rs3/properties/joint/GeosyntheticHyperbolic.py

@@ -0,0 +1,158 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.JointStageFactorService_pb2_grpc as JointStageFactorService_pb2_grpc
+class GeosyntheticHyperbolicBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getK(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("K")
+    def setK(self, value: float):
+        self._propertyAccessor.setDoubleProperty("K", value)
+    def getDeltaPr(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("DeltaPr")
+    def setDeltaPr(self, value: float):
+        self._propertyAccessor.setDoubleProperty("DeltaPr", value)
+    def getHasWorkSoftening(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasWorkSoftening")
+    def setHasWorkSoftening(self, value: bool):
+        self._propertyAccessor.setBoolValue("HasWorkSoftening", value)
+    def getNormalStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("NormalStiffness")
+    def setNormalStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("NormalStiffness", value)
+    def getShearStiffness(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ShearStiffness")
+    def setShearStiffness(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ShearStiffness", value)
+    def getAdhesionAtSigInf(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PeakAdhesion")
+    def setAdhesionAtSigInf(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PeakAdhesion", value)
+    def getFrictionAngleAtSig0(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PeakFrictionAngle")
+    def setFrictionAngleAtSig0(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PeakFrictionAngle", value)
+    def getResidualAdhesionAtSigInf(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualAdhesion")
+    def setResidualAdhesionAtSigInf(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ResidualAdhesion", value)
+    def getResidualFrictionAngleAtSig0(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualFrictionAngle")
+    def setResidualFrictionAngleAtSig0(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ResidualFrictionAngle", value)
+    def getHasDeltaPr(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasDeltaPr")
+    def setHasDeltaPr(self, value: bool):
+        self._propertyAccessor.setBoolValue("HasDeltaPr", value)
+    def getProperties(self):
+        return {
+            "K": self.getK(),
+            "DeltaPr": self.getDeltaPr(),
+            "HasWorkSoftening": self.getHasWorkSoftening(),
+            "NormalStiffness": self.getNormalStiffness(),
+            "ShearStiffness": self.getShearStiffness(),
+            "AdhesionAtSigInf": self.getAdhesionAtSigInf(),
+            "FrictionAngleAtSig0": self.getFrictionAngleAtSig0(),
+            "ResidualAdhesionAtSigInf": self.getResidualAdhesionAtSigInf(),
+            "ResidualFrictionAngleAtSig0": self.getResidualFrictionAngleAtSig0(),
+            "HasDeltaPr": self.getHasDeltaPr(),
+        }
+    def setProperties(self, K: float = None, DeltaPr: float = None, HasWorkSoftening: bool = None, NormalStiffness: float = None, ShearStiffness: float = None, AdhesionAtSigInf: float = None, FrictionAngleAtSig0: float = None, ResidualAdhesionAtSigInf: float = None, ResidualFrictionAngleAtSig0: float = None, HasDeltaPr: bool = None):
+        if K is not None:
+            self.setK(K)
+        if DeltaPr is not None:
+            self.setDeltaPr(DeltaPr)
+        if HasWorkSoftening is not None:
+            self.setHasWorkSoftening(HasWorkSoftening)
+        if NormalStiffness is not None:
+            self.setNormalStiffness(NormalStiffness)
+        if ShearStiffness is not None:
+            self.setShearStiffness(ShearStiffness)
+        if AdhesionAtSigInf is not None:
+            self.setAdhesionAtSigInf(AdhesionAtSigInf)
+        if FrictionAngleAtSig0 is not None:
+            self.setFrictionAngleAtSig0(FrictionAngleAtSig0)
+        if ResidualAdhesionAtSigInf is not None:
+            self.setResidualAdhesionAtSigInf(ResidualAdhesionAtSigInf)
+        if ResidualFrictionAngleAtSig0 is not None:
+            self.setResidualFrictionAngleAtSig0(ResidualFrictionAngleAtSig0)
+        if HasDeltaPr is not None:
+            self.setHasDeltaPr(HasDeltaPr)
+class GeosyntheticHyperbolicStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, JointStageFactorService_pb2_grpc.JointStageFactorServiceStub(client.channel))
+    def getDeltaPrFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_DeltaPrFactor")
+    def getKFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_KFactor")
+    def getNormalStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_NormalStiffness")
+    def getAdhesionAtSigInfFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_PeakAdhesionFactor")
+    def getFrictionAngleAtSig0Factor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_PeakFrictionAngleFactor")
+    def getResidualAdhesionAtSigInfFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_ResidualAdhesionFactor")
+    def getResidualFrictionAngleAtSig0Factor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_ResidualFrictionAngleFactor")
+    def getShearStiffnessFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Geosynthetic_ShearStiffness")
+class GeosyntheticHyperbolicDefinedStageFactorBase(GeosyntheticHyperbolicStageFactorBase):
+    def setDeltaPrFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_DeltaPrFactor", value)
+    def setKFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_KFactor", value)
+    def setNormalStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_NormalStiffness", value)
+    def setAdhesionAtSigInfFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_PeakAdhesionFactor", value)
+    def setFrictionAngleAtSig0Factor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_PeakFrictionAngleFactor", value)
+    def setResidualAdhesionAtSigInfFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_ResidualAdhesionFactor", value)
+    def setResidualFrictionAngleAtSig0Factor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_ResidualFrictionAngleFactor", value)
+    def setShearStiffnessFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Geosynthetic_ShearStiffness", value)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.stageFactors.StageFactorBaseInterfaces import AbsoluteStageFactorInterface
+import rs3.generatedFiles.JointService_pb2_grpc as JointService_pb2_grpc
+import rs3.generatedFiles.JointService_pb2 as JointService_pb2
+
+class GeosyntheticHyperbolicStageFactor(GeosyntheticHyperbolicStageFactorBase):
+    """
+	Examples:
+		See :ref:`joint_example`.
+	"""
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+        
+class GeosyntheticHyperbolicDefinedStageFactor(GeosyntheticHyperbolicStageFactor, GeosyntheticHyperbolicDefinedStageFactorBase):
+    """
+	Examples:
+		See :ref:`joint_example`.
+	"""
+    pass
+
+class GeosyntheticHyperbolic(GeosyntheticHyperbolicBase):
+    """
+	Examples:
+		See :ref:`joint_example`.
+	"""
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._jointService = JointService_pb2_grpc.JointServiceStub(self._client.channel)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[GeosyntheticHyperbolicDefinedStageFactor, GeosyntheticHyperbolicStageFactor](id, client, GeosyntheticHyperbolicDefinedStageFactor, GeosyntheticHyperbolicStageFactor)
+    def getAllowSlipStartFromStage(self) -> int:
+        request = JointService_pb2.GetSlipStageRequest(jointId=self._objectId)
+        respond : JointService_pb2.GetSlipStageResponse = self._client.callFunction(self._jointService.GetSlipStage, request)
+        return respond.slipStageNumber
+    def setAllowSlipStartFromStage(self, value: int):
+        request = JointService_pb2.SetSlipStageRequest(jointId=self._objectId, slipStageNumber=value)
+        self._client.callFunction(self._jointService.SetSlipStage, request)

rs3/properties/joint/Joint.py

@@ -0,0 +1,176 @@
+# Generated by RPCBinder in RFC_Common.
+from rs3._client import Client
+from ._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.properties.IPropertyGroupAccessors import IPropertyGroupAccessors
+from rs3.properties.stageFactors.IStageFactorBase import IStageFactorBase
+import rs3.generatedFiles.JointStageFactorService_pb2_grpc as JointStageFactorService_pb2_grpc
+class JointBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getInitialJointDeformation(self) -> bool:
+        return self._propertyAccessor.getBoolValue("InitialJointDeformation")
+    def setInitialJointDeformation(self, value: bool):
+        self._propertyAccessor.setBoolValue("InitialJointDeformation", value)
+    def getPermeable(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsPermeable")
+    def setPermeable(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsPermeable", value)
+    def getApplySSR(self) -> bool:
+        return self._propertyAccessor.getBoolValue("ApplySSR")
+    def setApplySSR(self, value: bool):
+        self._propertyAccessor.setBoolValue("ApplySSR", value)
+    def getApplyPorePressure(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasGroundWaterPorePressure")
+    def setApplyPorePressure(self, value: bool):
+        self._propertyAccessor.setBoolValue("HasGroundWaterPorePressure", value)
+    def getApplyAdditionalPressureInsideJoint(self) -> bool:
+        return self._propertyAccessor.getBoolValue("HasAdditionalPressure")
+    def setApplyAdditionalPressureInsideJoint(self, value: bool):
+        self._propertyAccessor.setBoolValue("HasAdditionalPressure", value)
+    def getAdditionalPressureInsideJoint(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("AdditionalPressure")
+    def setAdditionalPressureInsideJoint(self, value: float):
+        self._propertyAccessor.setDoubleProperty("AdditionalPressure", value)
+    def getApplyStageFactors(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsStaged")
+    def setApplyStageFactors(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsStaged", value)
+    def getProperties(self):
+        return {
+            "InitialJointDeformation": self.getInitialJointDeformation(),
+            "Permeable": self.getPermeable(),
+            "ApplySSR": self.getApplySSR(),
+            "ApplyPorePressure": self.getApplyPorePressure(),
+            "ApplyAdditionalPressureInsideJoint": self.getApplyAdditionalPressureInsideJoint(),
+            "AdditionalPressureInsideJoint": self.getAdditionalPressureInsideJoint(),
+            "ApplyStageFactors": self.getApplyStageFactors(),
+        }
+    def setProperties(self, InitialJointDeformation: bool = None, Permeable: bool = None, ApplySSR: bool = None, ApplyPorePressure: bool = None, ApplyAdditionalPressureInsideJoint: bool = None, AdditionalPressureInsideJoint: float = None, ApplyStageFactors: bool = None):
+        if InitialJointDeformation is not None:
+            self.setInitialJointDeformation(InitialJointDeformation)
+        if Permeable is not None:
+            self.setPermeable(Permeable)
+        if ApplySSR is not None:
+            self.setApplySSR(ApplySSR)
+        if ApplyPorePressure is not None:
+            self.setApplyPorePressure(ApplyPorePressure)
+        if ApplyAdditionalPressureInsideJoint is not None:
+            self.setApplyAdditionalPressureInsideJoint(ApplyAdditionalPressureInsideJoint)
+        if AdditionalPressureInsideJoint is not None:
+            self.setAdditionalPressureInsideJoint(AdditionalPressureInsideJoint)
+        if ApplyStageFactors is not None:
+            self.setApplyStageFactors(ApplyStageFactors)
+class JointStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, JointStageFactorService_pb2_grpc.JointStageFactorServiceStub(client.channel))
+    def getAdditionalPressureInsideJointFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Other_AdditionalPressureFactor")
+    def getGroundwaterPressureFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Other_GroundWaterFactor")
+class JointDefinedStageFactorBase(JointStageFactorBase):
+    def setAdditionalPressureInsideJointFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Other_AdditionalPressureFactor", value)
+    def setGroundwaterPressureFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Other_GroundWaterFactor", value)
+
+################ Code below this line will not be overridden ################
+import rs3.generatedFiles.JointDataService_pb2_grpc as JointDataService_pb2_grpc
+import rs3.generatedFiles.JointDataService_pb2 as JointDataService_pb2
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3.properties.PropertyEnums import *
+from rs3.properties.joint.NoneSlip import NoneSlip
+from rs3.properties.joint.MohrCoulomb import MohrCoulomb
+from rs3.properties.joint.BartonBandis import BartonBandis
+from rs3.properties.joint.GeosyntheticHyperbolic import GeosyntheticHyperbolic
+from rs3.properties.joint.MaterialDependent import MaterialDependent
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+from rs3.ColorPicker import ColorPicker
+class JointProperty(JointBase):
+    """
+    Define joint properties.
+
+    Attributes:
+        NoneSlip (NoneSlip): Reference object for modifying property.
+        MohrCoulomb (MohrCoulomb): Reference object for modifying property.
+        BartonBandis (BartonBandis): Reference object for modifying property.
+        GeosyntheticHyperbolic (SwelGeosyntheticHyperboliclex): Reference object for modifying property.
+        MaterialDependent (MaterialDependent): Reference object for modifying property.
+
+    Examples:
+        See :ref:`joint_example`.
+    """
+    def __init__(self, client : Client, jointID : str):
+        super().__init__(client, jointID)
+        self._jointDataService = JointDataService_pb2_grpc.JointDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, jointID, self._jointDataService)
+        self.NoneSlip = NoneSlip(client, jointID)
+        self.MohrCoulomb = MohrCoulomb(client, jointID)
+        self.BartonBandis = BartonBandis(client, jointID)
+        self.GeosyntheticHyperbolic = GeosyntheticHyperbolic(client, jointID)
+        self.MaterialDependent = MaterialDependent(client, jointID)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[JointDefinedStageFactorBase, JointStageFactorBase](jointID, client, JointDefinedStageFactorBase, JointStageFactorBase)
+
+    def getJointName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+    def setJointName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+
+    def setJointColor(self, *args):
+        """
+        Sets the RGBA color for the object.
+
+        Raises:
+            ValueError: If inputs are invalid or out of range.
+            
+        Notes:
+            Accepted formats:
+                - setColor(red, green, blue)
+                - setColor(red, green, blue, alpha)
+                - setColor("#RRGGBB")
+                - setColor("#RRGGBBAA")
+                - setColor(ColorType.Rose)
+                - setColor(0xE1E4FF)  # Integer COLORREF
+
+        """
+        color_bytes = ColorPicker._setColorValidation(*args)
+        request = CommonMessages_pb2.SetColorRequest(objectId=self._objectId, value=color_bytes)
+        self._client.callFunction(self._jointDataService.SetColorProperty, request)
+    def getJointColor(self) -> tuple[int, int, int, int]:
+        """
+        Retrieves the RGBA color of the object.
+
+        Returns:
+            tuple[int, int, int, int]: A tuple of four integers representing the red, green, blue, and alpha components of the object's color, each in the range [0, 255].
+        """
+        request = CommonMessages_pb2.GetColorRequest(objectId=self._objectId)
+        response : CommonMessages_pb2.GetColorResponse = self._client.callFunction(self._jointDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha
+
+    def getConstitutiveModel(self) -> JointConstitutiveModelTypes:
+        """
+        UI Label:
+            Failure Criterion
+        """
+        return self._propertyAccessor.getEnumValue("InterfaceTypeIndex", JointConstitutiveModelTypes)
+    def setConstitutiveModel(self, constitutiveModel : JointConstitutiveModelTypes):
+        """
+        UI Label:
+            Failure Criterion
+        """
+        self._propertyAccessor.setEnumValue("InterfaceTypeIndex", constitutiveModel.value)
+
+    def getPiezoID(self) -> str:
+        request = JointDataService_pb2.GetPiezoToUseRequest(jointId=self._objectId)
+        response : JointDataService_pb2.GetPiezoToUseResponse = self._client.callFunction(self._jointDataService.GetPiezoToUse, request)
+        return response.piezoName
+    def setPiezoID(self, value: str):
+        request = JointDataService_pb2.SetPiezoToUseRequest(jointId=self._objectId, piezoName=value)
+        self._client.callFunction(self._jointDataService.SetPiezoToUse, request)
+
+    def getAdditionalPressureType(self) -> AdditionalPressureType:
+        return AdditionalPressureType(self._propertyAccessor.getBoolValue("HasGroundWaterPorePressure"))
+    def setAdditionalPressureType(self, value: AdditionalPressureType):
+        self._propertyAccessor.setBoolValue("HasGroundWaterPorePressure", value.value)