RS3Scripting 4.42.0__py3-none-any.whl

rs3/properties/_PropertyAccessor.py

@@ -0,0 +1,111 @@
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+import rs3.generatedFiles.MaterialHydraulicModelService_pb2 as MaterialHydraulicModelService_pb2
+import rs3.generatedFiles.MaterialHydraulicModelService_pb2_grpc as MaterialHydraulicModelService_pb2_grpc
+
+class PropertyAccessor:
+    def __init__(self, client : Client, objectId : str, stub):
+        self.objectId = objectId
+        self._client = client
+        self._stub = stub
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self.objectId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._stub.GetProperty, request)
+        return response.value
+    
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetPropertyRequest(objectId=self.objectId, 
+                                                        propertyName=propertyName,
+                                                        value=value)
+        self._client.callFunction(self._stub.SetProperty, request)
+
+    def getDoubleProperty(self, propertyName : str) -> float:
+        return self._getProperty(propertyName).doubleValue
+
+    def setDoubleProperty(self, propertyName : str, value : float):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(doubleValue=value))
+
+    def getFloatProperty(self, propertyName : str) -> float:
+        return self._getProperty(propertyName).floatValue
+    
+    def setFloatProperty(self, propertyName : str, value : float):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(floatValue=value))
+
+    def getIntProperty(self, propertyName : str) -> int:
+        return self._getProperty(propertyName).intValue
+    
+    def setIntProperty(self, propertyName : str, value : int):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(intValue=value))
+
+    def getLongProperty(self, propertyName : str) -> int:
+        return self._getProperty(propertyName).longValue
+    
+    def setLongProperty(self, propertyName : str, value : int):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(longValue=value))
+
+    def getUintProperty(self, propertyName: str) -> int:
+        return self._getProperty(propertyName).uintValue
+
+    def setUintProperty(self, propertyName: str, value: int):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(uintValue=value))
+
+    def getUlongProperty(self, propertyName: str) -> int:
+        return self._getProperty(propertyName).ulongValue
+
+    def setUlongProperty(self, propertyName: str, value: int):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(ulongValue=value))
+
+    def getBoolValue(self, propertyName: str) -> bool:
+        return self._getProperty(propertyName).boolValue
+
+    def setBoolValue(self, propertyName: str, value: bool):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(boolValue=value))
+
+    def getStringValue(self, propertyName: str) -> str:
+        return self._getProperty(propertyName).stringValue
+
+    def setStringValue(self, propertyName: str, value: str):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(stringValue=value))
+
+    def getBytesValue(self, propertyName: str) -> bytes:
+        return self._getProperty(propertyName).bytesValue
+
+    def setBytesValue(self, propertyName: str, value: bytes):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(bytesValue=value))
+        
+    def getEnumValue(self, propertyName: str, enumType):
+        return enumType(self._getProperty(propertyName).enumValue)
+    
+    def setEnumValue(self, propertyName: str, value: str):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(enumValue=value))
+        
+    def getVector3DValue(self, propertyName: str) -> tuple[float, float, float]:
+        response = self._getProperty(propertyName).vector3DValue
+        return (response.x, response.y, response.z)
+    
+    def setVector3DValue(self, propertyName: str, value: tuple[float, float, float]):
+        request = CommonMessages_pb2.PropertyValue(vector3DValue=CommonMessages_pb2.Vector3D(x=value[0], y=value[1], z=value[2]))
+        self._setProperty(propertyName, request)    
+    
+    def getPoint3DValue(self, propertyName: str) -> tuple[float, float, float]:
+        response = self._getProperty(propertyName).point3DValue
+        return (response.x, response.y, response.z)
+    
+    def setPoint3DValue(self, propertyName: str, value: tuple[float, float, float]):
+        request = CommonMessages_pb2.PropertyValue(point3DValue=CommonMessages_pb2.Point3D(x=value[0], y=value[1], z=value[2]))
+        self._setProperty(propertyName, request)
+        
+class CustomHydraulicModelPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str, projectId : str):
+        self._stub = MaterialHydraulicModelService_pb2_grpc.MaterialHydraulicModelServiceStub(client.channel)
+        super().__init__(client, objectId, self._stub)
+        self._projectId = projectId        
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = MaterialHydraulicModelService_pb2.GetCustomHydraulicModelPropertyRequest(objectId=self.objectId, projectId=self._projectId, propertyName=propertyName)
+        response : MaterialHydraulicModelService_pb2.GetCustomHydraulicModelPropertyResponse = self._client.callFunction(self._stub.GetCustomHydraulicModelProperty, request)
+        return response.value
+    
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = MaterialHydraulicModelService_pb2.SetCustomHydraulicModelPropertyRequest(objectId=self.objectId, projectId=self._projectId, propertyName=propertyName, value=value)
+        self._client.callFunction(self._stub.SetCustomHydraulicModelProperty, request)

rs3/properties/beam/Beam.py

@@ -0,0 +1,86 @@
+# 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
+class BeamBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getApplyStageFactors(self) -> bool:
+        return self._propertyAccessor.getBoolValue("StageProperties")
+    def setApplyStageFactors(self, value: bool):
+        self._propertyAccessor.setBoolValue("StageProperties", value)
+    def getProperties(self):
+        return {
+            "ApplyStageFactors": self.getApplyStageFactors(),
+        }
+    def setProperties(self, ApplyStageFactors: bool = None):
+        if ApplyStageFactors is not None:
+            self.setApplyStageFactors(ApplyStageFactors)
+
+################ Code below this line will not be overridden ################
+import rs3.generatedFiles.BeamDataService_pb2_grpc as BeamDataService_pb2_grpc
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3.properties.PropertyEnums import *
+from rs3.properties.beam.Standard import Standard
+from rs3.properties.beam.Truss import Truss
+from rs3.ColorPicker import ColorPicker
+
+class BeamProperty(BeamBase):
+    """
+    Define beam properties.
+
+    Attributes:
+        Standard (Standard): Reference object for modifying property.
+        Truss (Truss): Reference object for modifying property.
+
+    Examples:
+        See :ref:`beam_example`.
+    """
+    def __init__(self, client : Client, beamID : str):
+        super().__init__(client, beamID)
+        self._beamDataService = BeamDataService_pb2_grpc.BeamDataServiceStub(self._client.channel)
+        self._basePropertyAccessor = PropertyAccessor(client, beamID, self._beamDataService)
+        self.Standard = Standard(client, beamID)
+        self.Truss = Truss(client, beamID)
+
+    def setBeamName(self, name : str):
+        self._basePropertyAccessor.setStringValue("Name", name)
+    def getBeamName(self) -> str:
+        return self._basePropertyAccessor.getStringValue("Name")
+    def setBeamType(self, beamType : BeamType):
+        self._basePropertyAccessor.setEnumValue("BeamType", beamType.value)
+    def getBeamType(self) -> BeamType:
+        return self._basePropertyAccessor.getEnumValue("BeamType", BeamType)
+    def setBeamColor(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._beamDataService.SetColorProperty, request)
+    def getBeamColor(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._beamDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha

rs3/properties/beam/BeamCommon.py

@@ -0,0 +1,175 @@
+# 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.BeamStageFactorService_pb2_grpc as BeamStageFactorService_pb2_grpc
+class BeamCommonBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getYoungsModulus(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Modulus")
+    def setYoungsModulus(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Modulus", value)
+    def getPoissonsRatio(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PoissonRatio")
+    def setPoissonsRatio(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PoissonRatio", value)
+    def getShearStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ShearStrength")
+    def setShearStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ShearStrength", value)
+    def getArea(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Area")
+    def setArea(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Area", value)
+    def getUnitWeight(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("UnitWeight")
+    def setUnitWeight(self, value: float):
+        self._propertyAccessor.setDoubleProperty("UnitWeight", value)
+    def getPreTensioning(self) -> bool:
+        return self._propertyAccessor.getBoolValue("PreTensioning")
+    def setPreTensioning(self, value: bool):
+        self._propertyAccessor.setBoolValue("PreTensioning", value)
+    def getPreTensioningForce(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PreTensioningForce")
+    def setPreTensioningForce(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PreTensioningForce", value)
+    def getIncludeWeightInStressAnalysis(self) -> bool:
+        return self._propertyAccessor.getBoolValue("WeightInAnalysis")
+    def setIncludeWeightInStressAnalysis(self, value: bool):
+        self._propertyAccessor.setBoolValue("WeightInAnalysis", value)
+    def getCompressiveStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PeakCompressiveStrength")
+    def setCompressiveStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PeakCompressiveStrength", value)
+    def getTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PeakTensileStrength")
+    def setTensileStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PeakTensileStrength", value)
+    def getResidualCompressiveStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualCompressiveStrength")
+    def setResidualCompressiveStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ResidualCompressiveStrength", value)
+    def getResidualTensileStrength(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ResidualTensileStrength")
+    def setResidualTensileStrength(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ResidualTensileStrength", value)
+    def getProperties(self):
+        return {
+            "YoungsModulus": self.getYoungsModulus(),
+            "PoissonsRatio": self.getPoissonsRatio(),
+            "ShearStrength": self.getShearStrength(),
+            "Area": self.getArea(),
+            "UnitWeight": self.getUnitWeight(),
+            "PreTensioning": self.getPreTensioning(),
+            "PreTensioningForce": self.getPreTensioningForce(),
+            "IncludeWeightInStressAnalysis": self.getIncludeWeightInStressAnalysis(),
+            "CompressiveStrength": self.getCompressiveStrength(),
+            "TensileStrength": self.getTensileStrength(),
+            "ResidualCompressiveStrength": self.getResidualCompressiveStrength(),
+            "ResidualTensileStrength": self.getResidualTensileStrength(),
+        }
+    def setProperties(self, YoungsModulus: float = None, PoissonsRatio: float = None, ShearStrength: float = None, Area: float = None, UnitWeight: float = None, PreTensioning: bool = None, PreTensioningForce: float = None, IncludeWeightInStressAnalysis: bool = None, CompressiveStrength: float = None, TensileStrength: float = None, ResidualCompressiveStrength: float = None, ResidualTensileStrength: float = None):
+        if YoungsModulus is not None:
+            self.setYoungsModulus(YoungsModulus)
+        if PoissonsRatio is not None:
+            self.setPoissonsRatio(PoissonsRatio)
+        if ShearStrength is not None:
+            self.setShearStrength(ShearStrength)
+        if Area is not None:
+            self.setArea(Area)
+        if UnitWeight is not None:
+            self.setUnitWeight(UnitWeight)
+        if PreTensioning is not None:
+            self.setPreTensioning(PreTensioning)
+        if PreTensioningForce is not None:
+            self.setPreTensioningForce(PreTensioningForce)
+        if IncludeWeightInStressAnalysis is not None:
+            self.setIncludeWeightInStressAnalysis(IncludeWeightInStressAnalysis)
+        if CompressiveStrength is not None:
+            self.setCompressiveStrength(CompressiveStrength)
+        if TensileStrength is not None:
+            self.setTensileStrength(TensileStrength)
+        if ResidualCompressiveStrength is not None:
+            self.setResidualCompressiveStrength(ResidualCompressiveStrength)
+        if ResidualTensileStrength is not None:
+            self.setResidualTensileStrength(ResidualTensileStrength)
+class BeamCommonStageFactorBase(IStageFactorBase):
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client, BeamStageFactorService_pb2_grpc.BeamStageFactorServiceStub(client.channel))
+    def getAreaFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_Area")
+    def getCompressiveStrengthFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_CompressiveStrengthPeak")
+    def getResidualCompressiveStrengthFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_CompressiveStrengthResidual")
+    def getPoissonsRatioFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_PoissonsRatio")
+    def getPretensionForceFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_PretensionForce")
+    def getTensileStrengthFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_TensileStrengthPeak")
+    def getResidualTensileStrengthFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_TensileStrengthResidual")
+    def getUnitWeightFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_UnitWeight")
+    def getYoungsModulusFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Common_YoungsModulus")
+class BeamCommonDefinedStageFactorBase(BeamCommonStageFactorBase):
+    def setAreaFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_Area", value)
+    def setCompressiveStrengthFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_CompressiveStrengthPeak", value)
+    def setResidualCompressiveStrengthFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_CompressiveStrengthResidual", value)
+    def setPoissonsRatioFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_PoissonsRatio", value)
+    def setPretensionForceFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_PretensionForce", value)
+    def setTensileStrengthFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_TensileStrengthPeak", value)
+    def setResidualTensileStrengthFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_TensileStrengthResidual", value)
+    def setUnitWeightFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_UnitWeight", value)
+    def setYoungsModulusFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Common_YoungsModulus", value)
+
+################ Code below this line will not be overridden ################     
+from rs3.properties.PropertyEnums import *
+class BeamCommonStageFactor(BeamCommonStageFactorBase):
+    """
+    Examples:
+        See :ref:`beam_example`.
+    """
+    def __init__(self, id: str, stageFactorId: str, client: Client):
+        super().__init__(id, stageFactorId, client)
+        
+class BeamCommonDefinedStageFactor(BeamCommonDefinedStageFactorBase):
+    """
+    Examples:
+        See :ref:`beam_example`.
+    """
+    pass
+
+class BeamCommon(BeamCommonBase):
+    """
+    Common base class for all beam-type structural elements.
+
+    ``BeamCommon`` defines the shared properties that are applicable to 
+    both Standard beam and Truss. 
+    
+    Examples:
+        See :ref:`beam_example`.
+    """
+    
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+
+    def setMaterialType(self, value : MaterialType):
+        self._propertyAccessor.setBoolValue("IsPlasticMaterial", value.value)
+    def getMaterialType(self) -> MaterialType:
+        return MaterialType(self._propertyAccessor.getBoolValue("IsPlasticMaterial"))

rs3/properties/beam/Standard.py

@@ -0,0 +1,97 @@
+# 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
+class StandardBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getIMin(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("IMin")
+    def setIMin(self, value: float):
+        self._propertyAccessor.setDoubleProperty("IMin", value)
+    def getIMax(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("IMax")
+    def setIMax(self, value: float):
+        self._propertyAccessor.setDoubleProperty("IMax", value)
+    def getProperties(self):
+        return {
+            "IMin": self.getIMin(),
+            "IMax": self.getIMax(),
+        }
+    def setProperties(self, IMin: float = None, IMax: float = None):
+        if IMin is not None:
+            self.setIMin(IMin)
+        if IMax is not None:
+            self.setIMax(IMax)
+
+################ Code below this line will not be overridden ################
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.beam.BeamCommon import BeamCommon, BeamCommonStageFactor, BeamCommonDefinedStageFactor
+import rs3.generatedFiles.BeamDataService_pb2_grpc as BeamDataService_pb2_grpc
+from rs3.properties.PropertyEnums import *
+
+class StandardBeamStageFactor(BeamCommonStageFactor):
+    """
+    Examples:
+        See :ref:`beam_example`.
+    """
+    def __init__(self, id : str, stageFactorID : str, client : Client):
+        super().__init__(id, stageFactorID, client)
+    def getMomentInertiaYFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Standard_MomentInertiaY")
+    def getMomentInertiaZFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Standard_MomentInertiaZ")
+    def getShearStrengthFactor(self) -> float:
+        return self._stageFactorPropertyAccessor.getDoubleProperty("Standard_ShearStrength")
+
+class StandardBeamDefinedStageFactor(StandardBeamStageFactor, BeamCommonDefinedStageFactor):
+    """
+    Examples:
+        See :ref:`beam_example`.
+    """
+    def setMomentInertiaYFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Standard_MomentInertiaY", value)
+    def setMomentInertiaZFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Standard_MomentInertiaZ", value)
+    def setShearStrengthFactor(self, value: float):
+        self._stageFactorPropertyAccessor.setDoubleProperty("Standard_ShearStrength", value)
+
+class Standard(BeamCommon, StandardBase):
+    """
+    Standard beam structural element.
+
+    This class represents a standard beam section. It **inherits all common
+    beam functionality** from :class:`BeamCommon.BeamCommon`, and **section-specific
+    properties** from :class:`StandardBase`.
+
+    The following intrinsic properties are exposed via ``StandardBase``:
+    
+    - ``IMin``: Minimum moment of inertia.
+    - ``IMax``: Maximum moment of inertia.
+
+    Stage-dependent modification factors for standard beam properties are
+    accessed through ``StageFactorInterface``, which provides:
+        
+    - Moment of inertia Y factor
+    - Moment of inertia Z factor
+    - Shear strength factor
+
+    For full documentation of common beam behavior and shared properties,
+    refer to ``BeamCommon.py``.
+
+    Examples:
+        See :ref:`beam_example`.
+
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._beamDataService = BeamDataService_pb2_grpc.BeamDataServiceStub(self._client.channel)
+        self._basePropertyAccessor = PropertyAccessor(client, id, self._beamDataService)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[StandardBeamDefinedStageFactor, StandardBeamStageFactor](id, client, StandardBeamDefinedStageFactor, StandardBeamStageFactor)
+
+    def setBeamElementFormulation(self, beamElementFormulation : BeamElementFormulation):
+        self._basePropertyAccessor.setEnumValue("ElementFormulation", beamElementFormulation.value)
+    def getBeamElementFormulation(self) -> BeamElementFormulation:
+        return self._basePropertyAccessor.getEnumValue("ElementFormulation", BeamElementFormulation)

rs3/properties/beam/Truss.py

@@ -0,0 +1,23 @@
+from rs3._client import Client
+from rs3.properties.stageFactors.StageFactorInterfaces import AbsoluteStageFactorInterface
+from rs3.properties.PropertyEnums import *
+from rs3.properties.beam import BeamCommon
+
+class Truss(BeamCommon.BeamCommon):
+    """
+    Truss structural element.
+
+    This class represents a truss member and **inherits all common beam
+    properties, methods, and behaviors** from :class:`BeamCommon.BeamCommon`.
+
+    No additional intrinsic properties are defined at the truss level beyond
+    what is provided by ``BeamCommon``. Users should refer to
+    ``BeamCommon.py`` for the complete list of available properties and
+    interfaces.
+
+    Examples:
+        See :ref:`beam_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self.StageFactorInterface = AbsoluteStageFactorInterface[BeamCommon.BeamCommonDefinedStageFactor, BeamCommon.BeamCommonStageFactor](id, client, BeamCommon.BeamCommonDefinedStageFactor, BeamCommon.BeamCommonStageFactor)

rs3/properties/beam/_PropertyAccessor.py

@@ -0,0 +1,9 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor
+import rs3.generatedFiles.BeamService_pb2_grpc as BeamService_pb2_grpc
+from rs3._client import Client
+class PropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, objectId : str, serviceStub = None):
+        if serviceStub is None:
+            serviceStub = BeamService_pb2_grpc.BeamServiceStub(client.channel)
+        super().__init__(client, objectId, serviceStub)
+

rs3/properties/bolt/Bolt.py

@@ -0,0 +1,81 @@
+import rs3.generatedFiles.BoltDataService_pb2_grpc as BoltDataService_pb2_grpc
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+from rs3.properties.PropertyEnums import *
+from rs3.properties.bolt.EndAnchored import EndAnchored
+from rs3.properties.bolt.FullyBonded import FullyBonded
+from rs3.properties.bolt.PlainStrandCable import PlainStrandCable
+from rs3.properties.bolt.Swellex import Swellex
+from rs3.properties.bolt.Tieback import Tieback
+from rs3.properties._PropertyAccessor import PropertyAccessor
+from rs3._proxyObject import _ProxyObject
+from rs3.ColorPicker import ColorPicker
+
+class BoltProperty(_ProxyObject):
+    """
+    Define bolt properties.
+
+    Attributes:
+        EndAnchored (EndAnchored): Reference object for modifying property.
+        FullyBonded (FullyBonded): Reference object for modifying property.
+        PlainStrandCable (PlainStrandCable): Reference object for modifying property.
+        Swellex (Swellex): Reference object for modifying property.
+        Tieback (Tieback): Reference object for modifying property.
+
+    Examples:
+        See :ref:`bolt_example`.
+        
+    """
+    def __init__(self, client : Client, boltID : str):
+        super().__init__(client, boltID)
+        self._boltDataService = BoltDataService_pb2_grpc.BoltDataServiceStub(self._client.channel)
+        self._propertyAccessor = PropertyAccessor(client, boltID, self._boltDataService)
+        self.EndAnchored = EndAnchored(client, boltID)
+        self.FullyBonded = FullyBonded(client, boltID)
+        self.PlainStrandCable = PlainStrandCable(client, boltID)
+        self.Swellex = Swellex(client, boltID)
+        self.Tieback = Tieback(client, boltID)
+
+    def getBoltName(self) -> str:
+        return self._propertyAccessor.getStringValue("Name")
+
+    def setBoltName(self, name):
+        self._propertyAccessor.setStringValue("Name", name)
+
+    def getBoltType(self) -> BoltTypes:
+        return self._propertyAccessor.getEnumValue("BoltType", BoltTypes)
+
+    def setBoltType(self, boltType : BoltTypes):
+        self._propertyAccessor.setEnumValue("BoltType", boltType.value)
+
+    def setBoltColor(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._boltDataService.SetColorProperty, request)
+    def getBoltColor(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._boltDataService.GetColorProperty, request)
+        red, green, blue, alpha = response.value
+        return red, green, blue, alpha

rs3/properties/bolt/EndAnchored.py

@@ -0,0 +1,77 @@
+# 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
+class EndAnchoredBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getTensileCapacity(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TensileCapacity")
+    def setTensileCapacity(self, value: float):
+        self._propertyAccessor.setDoubleProperty("TensileCapacity", value)
+    def getResidualTensileCapacity(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("TensileCapacityResidual")
+    def setResidualTensileCapacity(self, value: float):
+        self._propertyAccessor.setDoubleProperty("TensileCapacityResidual", value)
+    def getPreTensioningForce(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("PreTensioningForce")
+    def setPreTensioningForce(self, value: float):
+        self._propertyAccessor.setDoubleProperty("PreTensioningForce", value)
+    def getBoltDiameter(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Diameter")
+    def setBoltDiameter(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Diameter", value)
+    def getConstantPretensioningForceInInstallStage(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsConstantForce")
+    def setConstantPretensioningForceInInstallStage(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsConstantForce", value)
+    def getBoltModulusE(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Modulus")
+    def setBoltModulusE(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Modulus", value)
+    def getFacePlates(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsAttachedFacePlates")
+    def setFacePlates(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsAttachedFacePlates", value)
+    def getProperties(self):
+        return {
+            "TensileCapacity": self.getTensileCapacity(),
+            "ResidualTensileCapacity": self.getResidualTensileCapacity(),
+            "PreTensioningForce": self.getPreTensioningForce(),
+            "BoltDiameter": self.getBoltDiameter(),
+            "ConstantPretensioningForceInInstallStage": self.getConstantPretensioningForceInInstallStage(),
+            "BoltModulusE": self.getBoltModulusE(),
+            "FacePlates": self.getFacePlates(),
+        }
+    def setProperties(self, TensileCapacity: float = None, ResidualTensileCapacity: float = None, PreTensioningForce: float = None, BoltDiameter: float = None, ConstantPretensioningForceInInstallStage: bool = None, BoltModulusE: float = None, FacePlates: bool = None):
+        if TensileCapacity is not None:
+            self.setTensileCapacity(TensileCapacity)
+        if ResidualTensileCapacity is not None:
+            self.setResidualTensileCapacity(ResidualTensileCapacity)
+        if PreTensioningForce is not None:
+            self.setPreTensioningForce(PreTensioningForce)
+        if BoltDiameter is not None:
+            self.setBoltDiameter(BoltDiameter)
+        if ConstantPretensioningForceInInstallStage is not None:
+            self.setConstantPretensioningForceInInstallStage(ConstantPretensioningForceInInstallStage)
+        if BoltModulusE is not None:
+            self.setBoltModulusE(BoltModulusE)
+        if FacePlates is not None:
+            self.setFacePlates(FacePlates)
+
+################ Code below this line will not be overridden ################
+
+class EndAnchored(EndAnchoredBase):
+    """
+	Examples:
+		See :ref:`bolt_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+
+
+
+
+