RS3Scripting 4.42.0__py3-none-any.whl

rs3/projectSettings/Stages.py

@@ -0,0 +1,162 @@
+from rs3.projectSettings.ProjectSettingEnums import *
+from rs3._client import Client
+from ._PropertyAccessor import StagesPropertyAccessor
+import rs3.generatedFiles.ProjectSettingsDataService_pb2_grpc as ProjectSettingsDataService_pb2_grpc
+import rs3.generatedFiles.ProjectSettingsDataService_pb2 as ProjectSettingsDataService_pb2
+from rs3._proxyObject import _ProxyObject
+
+
+class Stages(_ProxyObject):
+    """
+    Edit the number of stages and define time, PWP method and dynamic analysis.
+    
+    Examples:
+        See :ref:`project_settings_example`.
+
+    """
+    def __init__(self, client: Client, projectId: str):
+        super().__init__(client, projectId)
+        self._propertyAccessor = StagesPropertyAccessor(client, projectId)
+        self._stagesService = ProjectSettingsDataService_pb2_grpc.ProjectSettingsDataServiceStub(self._client.channel)
+
+    def getDefinedStageNames(self) -> list[str]:
+        request = ProjectSettingsDataService_pb2.GetDefinedStageNamesRequest(_projectId=self._objectId)
+        result_ = self._client.callFunction(self._stagesService.GetDefinedStageNames, request)
+        result = [obj for obj in result_.result]
+        return result
+
+    def setTotalNumberOfStages(self, numberOfStages: int):
+        request = ProjectSettingsDataService_pb2.SetTotalNumberOfStagesRequest(_projectId=self._objectId, numberOfStages=numberOfStages)
+        self._client.callFunction(self._stagesService.SetTotalNumberOfStages, request)
+
+    def addStages(self, numberOfStages: int, referenceStage: int = -1):
+        """
+        Add one or more new stages to the project.
+
+        Parameters:
+            numberOfStages (int): The number of stages to add. Must be a positive integer. Default is 1.
+            referenceStage (int): The index of the stage **after which** new stages will be inserted.
+                                If -1 (default), stages are added at the end.
+
+        Behavior:
+            - Each value is interpreted as the actual stage number (not zero-based index).
+            - If referenceStage is -1 (or omitted), new stages are appended at the end of the current stage list.
+            - If referenceStage is a valid index (1-based), new stages are inserted after that stage.
+
+        Raises:
+            Exception if the number of stages is invalid or the reference index is out of bounds.
+
+        Examples:
+            >>> # Add 2 stages at the end of the project
+            >>> model.ProjectSettings.Stages.addStages(2, -1)
+
+            >>> # Add 3 stages after the stage 2
+            >>> model.ProjectSettings.Stages.addStages(3, 2)
+
+            >>> # Add 2 stages at the end (same as passing -1)
+            >>> model.ProjectSettings.Stages.addStages(numberOfStages=2)
+
+            >>> # Add 1 stage after the stage 5
+            >>> model.ProjectSettings.Stages.addStages(numberOfStages=1, referenceStage=5)
+            
+        """
+        request = ProjectSettingsDataService_pb2.AddStagesRequest(_projectId=self._objectId, referenceStage=referenceStage, numberOfStages=numberOfStages)
+        self._client.callFunction(self._stagesService.AddStages, request)
+
+    def removeStages(self, numberOfStages: int, startingStage: int = -1):
+        """
+        Remove one or more stages from the project.
+
+        Parameters:
+            numberOfStages (int): The number of stages to remove. Must be a non-negative integer. Default is 1.
+            startingStage (int): The index of the first stage to remove. If -1 (default), stages are removed from the end.
+
+        Behavior:
+            - Each value is interpreted as the actual stage number (not zero-based index).
+            - If `startingStage` is -1, the last `numberOfStages` stages are removed from the end of the stage list.
+            - If `startingStage` is a valid index (1-based), removal begins at that starting stage and removes the next 
+              `numberOfStages` stages (including the stage at `startingStage`).
+
+        Raises:
+            Exception if:
+                - `numberOfStages` is negative
+                - `startingStage` is less than -1
+                - The range defined by `startingStage` and `numberOfStages` exceeds the available stages
+
+        Examples:
+            >>> # Remove 2 stages from the end
+            >>> model.ProjectSettings.Stages.removeStages(2, -1)
+
+            >>> # Remove 3 stages starting from stage 3 (removes stages 3, 4, 5)
+            >>> model.ProjectSettings.Stages.removeStages(3, 3)
+
+            >>> # Remove 1 stage at stage 3
+            >>> model.ProjectSettings.Stages.removeStages(startingStage=3)
+
+            >>> # Remove 2 stages from the end (same as passing -1 explicitly)
+            >>> model.ProjectSettings.Stages.removeStages(numberOfStages=2)
+            
+        """
+        request = ProjectSettingsDataService_pb2.DeleteStagesRequest(_projectId=self._objectId, startingStage=startingStage, numberOfStages=numberOfStages)
+        self._client.callFunction(self._stagesService.DeleteStages, request)
+
+    def removeStagesByList(self, list: list[int]):
+        """
+        Remove specific stages from the project by specifying their stage numbers (1-based).
+
+        Parameters:
+            list (list[int]): A list of **actual stage numbers** (not zero-based index) to be removed.
+                            The order of stage numbers in the list does not matter.
+                            Duplicates are ignored. An empty list will raise an exception.
+
+        Behavior:
+            - Each value in the list is interpreted as the actual stage number (not zero-based index).
+            - If any stage number is invalid (less than 1 or greater than total number of stages), an exception will be raised.
+            - Valid and unique stages in the list will be removed from the project.
+
+        Raises:
+            Exception if:
+                - The list is empty
+                - Any stage number is less than 1
+                - Any stage number exceeds the total number of defined stages
+
+        Examples:
+            >>> # Assume there are 13 stages in the model.
+            >>> # Remove stages 3, 8, and 2
+            >>> model.ProjectSettings.Stages.removeStagesByList([3, 8, 2])
+
+            >>> # Raises exception: list is empty
+            >>> model.ProjectSettings.Stages.removeStagesByList([])
+
+            >>> # Raises exception: -2 is not a valid stage number
+            >>> model.ProjectSettings.Stages.removeStagesByList([5, 8, -2])
+
+            >>> # Raises exception: 15 exceeds current stage count
+            >>> model.ProjectSettings.Stages.removeStagesByList([1, 15, 2])
+        """
+        request = ProjectSettingsDataService_pb2.DeleteStagesByListRequest( _projectId=self._objectId, stageIndices=list)
+        self._client.callFunction(self._stagesService.DeleteStagesByList, request)
+
+    def setName(self, stageNumber: int, name: str):
+        self._propertyAccessor.setStringValue("Name", stageNumber, name)
+
+    def getName(self, stageNumber: int) -> str:
+        return self._propertyAccessor.getStringValue("Name", stageNumber)
+
+    def setTime(self, stageNumber: int, value: float):
+        self._propertyAccessor.setDoubleProperty("Time", stageNumber, value)
+
+    def getTime(self, stageNumber: int) -> float:
+        return self._propertyAccessor.getDoubleProperty("Time", stageNumber)
+
+    def setPWPMethod(self, stageNumber: int, value: PWPMethod):
+        self._propertyAccessor.setEnumValue("pwp_method", stageNumber, value.value)
+
+    def getPWPMethod(self, stageNumber: int) -> PWPMethod:
+        return self._propertyAccessor.getEnumValue("pwp_method", stageNumber, PWPMethod)
+
+    def setIsDynamicStage(self, stageNumber: int, value: bool):
+        self._propertyAccessor.setBoolValue("IsDynamic", stageNumber, value)
+
+    def getIsDynamicStage(self, stageNumber: int) -> bool:
+        return self._propertyAccessor.getBoolValue("IsDynamic", stageNumber)

rs3/projectSettings/StressAnalysis.py

@@ -0,0 +1,183 @@
+# 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 StressAnalysisBase(_ProxyObject, IPropertyGroupAccessors):
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = PropertyAccessor(client, id)
+    def getIterations(self) -> int:
+        return self._propertyAccessor.getIntProperty("Iterations")
+    def setIterations(self, value: int):
+        self._propertyAccessor.setIntProperty("Iterations", value)
+    def getTolerance(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("Tolerance")
+    def setTolerance(self, value: float):
+        self._propertyAccessor.setDoubleProperty("Tolerance", value)
+    def getNumberLoadSteps(self) -> int:
+        return self._propertyAccessor.getIntProperty("NumberLoadSteps")
+    def setNumberLoadSteps(self, value: int):
+        self._propertyAccessor.setIntProperty("NumberLoadSteps", value)
+    def getIterationsMin(self) -> int:
+        return self._propertyAccessor.getIntProperty("IterationsMin")
+    def setIterationsMin(self, value: int):
+        self._propertyAccessor.setIntProperty("IterationsMin", value)
+    def getLoadIncrementInitial(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("LoadIncrementInitial")
+    def setLoadIncrementInitial(self, value: float):
+        self._propertyAccessor.setDoubleProperty("LoadIncrementInitial", value)
+    def getLoadIncrementMin(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("LoadIncrementMin")
+    def setLoadIncrementMin(self, value: float):
+        self._propertyAccessor.setDoubleProperty("LoadIncrementMin", value)
+    def getLoadIncrementMax(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("LoadIncrementMax")
+    def setLoadIncrementMax(self, value: float):
+        self._propertyAccessor.setDoubleProperty("LoadIncrementMax", value)
+    def getIterationsTrackConvergence(self) -> int:
+        return self._propertyAccessor.getIntProperty("IterationsTrackConvergence")
+    def setIterationsTrackConvergence(self, value: int):
+        self._propertyAccessor.setIntProperty("IterationsTrackConvergence", value)
+    def getScaleForceIncrementUp(self) -> bool:
+        return self._propertyAccessor.getBoolValue("ScaleForceIncrementUp")
+    def setScaleForceIncrementUp(self, value: bool):
+        self._propertyAccessor.setBoolValue("ScaleForceIncrementUp", value)
+    def getScaleForceIncrementUpVal(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ScaleForceIncrementUpVal")
+    def setScaleForceIncrementUpVal(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ScaleForceIncrementUpVal", value)
+    def getScaleForceIncrementDown(self) -> bool:
+        return self._propertyAccessor.getBoolValue("ScaleForceIncrementDown")
+    def setScaleForceIncrementDown(self, value: bool):
+        self._propertyAccessor.setBoolValue("ScaleForceIncrementDown", value)
+    def getScaleForceIncrementDownVal(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("ScaleForceIncrementDownVal")
+    def setScaleForceIncrementDownVal(self, value: float):
+        self._propertyAccessor.setDoubleProperty("ScaleForceIncrementDownVal", value)
+    def getIsAcceleratedConvergenceActive(self) -> bool:
+        return self._propertyAccessor.getBoolValue("IsAcceleratedConvergenceActive")
+    def setIsAcceleratedConvergenceActive(self, value: bool):
+        self._propertyAccessor.setBoolValue("IsAcceleratedConvergenceActive", value)
+    def getAccelerateInitialStiffness(self) -> bool:
+        return self._propertyAccessor.getBoolValue("AccelerateInitialStiffness")
+    def setAccelerateInitialStiffness(self, value: bool):
+        self._propertyAccessor.setBoolValue("AccelerateInitialStiffness", value)
+    def getAlphaMin(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("AlphaMin")
+    def setAlphaMin(self, value: float):
+        self._propertyAccessor.setDoubleProperty("AlphaMin", value)
+    def getAlphaMax(self) -> float:
+        return self._propertyAccessor.getDoubleProperty("AlphaMax")
+    def setAlphaMax(self, value: float):
+        self._propertyAccessor.setDoubleProperty("AlphaMax", value)
+    def getAbortUponFailure(self) -> bool:
+        return self._propertyAccessor.getBoolValue("AbortUponFailure")
+    def setAbortUponFailure(self, value: bool):
+        self._propertyAccessor.setBoolValue("AbortUponFailure", value)
+    def getEnableFileRecovery(self) -> bool:
+        return self._propertyAccessor.getBoolValue("EnableFileRecovery")
+    def setEnableFileRecovery(self, value: bool):
+        self._propertyAccessor.setBoolValue("EnableFileRecovery", value)
+    def getTensileFailureReduceHoekBrownTensileStrengthToZero(self) -> bool:
+        return self._propertyAccessor.getBoolValue("is_tensile_failure_HoekBrown")
+    def setTensileFailureReduceHoekBrownTensileStrengthToZero(self, value: bool):
+        self._propertyAccessor.setBoolValue("is_tensile_failure_HoekBrown", value)
+    def getTensileFailureReduceShearStrengthToResidual(self) -> bool:
+        return self._propertyAccessor.getBoolValue("is_tensile_failure_shear_strehgth")
+    def setTensileFailureReduceShearStrengthToResidual(self, value: bool):
+        self._propertyAccessor.setBoolValue("is_tensile_failure_shear_strehgth", value)
+    def getUseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion(self) -> bool:
+        return self._propertyAccessor.getBoolValue("UseDefaultMaterialForAdvancedMaterialsInPlasticRegion")
+    def setUseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion(self, value: bool):
+        self._propertyAccessor.setBoolValue("UseDefaultMaterialForAdvancedMaterialsInPlasticRegion", value)
+    def getProperties(self):
+        return {
+            "Iterations": self.getIterations(),
+            "Tolerance": self.getTolerance(),
+            "NumberLoadSteps": self.getNumberLoadSteps(),
+            "IterationsMin": self.getIterationsMin(),
+            "LoadIncrementInitial": self.getLoadIncrementInitial(),
+            "LoadIncrementMin": self.getLoadIncrementMin(),
+            "LoadIncrementMax": self.getLoadIncrementMax(),
+            "IterationsTrackConvergence": self.getIterationsTrackConvergence(),
+            "ScaleForceIncrementUp": self.getScaleForceIncrementUp(),
+            "ScaleForceIncrementUpVal": self.getScaleForceIncrementUpVal(),
+            "ScaleForceIncrementDown": self.getScaleForceIncrementDown(),
+            "ScaleForceIncrementDownVal": self.getScaleForceIncrementDownVal(),
+            "IsAcceleratedConvergenceActive": self.getIsAcceleratedConvergenceActive(),
+            "AccelerateInitialStiffness": self.getAccelerateInitialStiffness(),
+            "AlphaMin": self.getAlphaMin(),
+            "AlphaMax": self.getAlphaMax(),
+            "AbortUponFailure": self.getAbortUponFailure(),
+            "EnableFileRecovery": self.getEnableFileRecovery(),
+            "TensileFailureReduceHoekBrownTensileStrengthToZero": self.getTensileFailureReduceHoekBrownTensileStrengthToZero(),
+            "TensileFailureReduceShearStrengthToResidual": self.getTensileFailureReduceShearStrengthToResidual(),
+            "UseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion": self.getUseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion(),
+        }
+    def setProperties(self, Iterations: int = None, Tolerance: float = None, NumberLoadSteps: int = None, IterationsMin: int = None, LoadIncrementInitial: float = None, LoadIncrementMin: float = None, LoadIncrementMax: float = None, IterationsTrackConvergence: int = None, ScaleForceIncrementUp: bool = None, ScaleForceIncrementUpVal: float = None, ScaleForceIncrementDown: bool = None, ScaleForceIncrementDownVal: float = None, IsAcceleratedConvergenceActive: bool = None, AccelerateInitialStiffness: bool = None, AlphaMin: float = None, AlphaMax: float = None, AbortUponFailure: bool = None, EnableFileRecovery: bool = None, TensileFailureReduceHoekBrownTensileStrengthToZero: bool = None, TensileFailureReduceShearStrengthToResidual: bool = None, UseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion: bool = None):
+        if Iterations is not None:
+            self.setIterations(Iterations)
+        if Tolerance is not None:
+            self.setTolerance(Tolerance)
+        if NumberLoadSteps is not None:
+            self.setNumberLoadSteps(NumberLoadSteps)
+        if IterationsMin is not None:
+            self.setIterationsMin(IterationsMin)
+        if LoadIncrementInitial is not None:
+            self.setLoadIncrementInitial(LoadIncrementInitial)
+        if LoadIncrementMin is not None:
+            self.setLoadIncrementMin(LoadIncrementMin)
+        if LoadIncrementMax is not None:
+            self.setLoadIncrementMax(LoadIncrementMax)
+        if IterationsTrackConvergence is not None:
+            self.setIterationsTrackConvergence(IterationsTrackConvergence)
+        if ScaleForceIncrementUp is not None:
+            self.setScaleForceIncrementUp(ScaleForceIncrementUp)
+        if ScaleForceIncrementUpVal is not None:
+            self.setScaleForceIncrementUpVal(ScaleForceIncrementUpVal)
+        if ScaleForceIncrementDown is not None:
+            self.setScaleForceIncrementDown(ScaleForceIncrementDown)
+        if ScaleForceIncrementDownVal is not None:
+            self.setScaleForceIncrementDownVal(ScaleForceIncrementDownVal)
+        if IsAcceleratedConvergenceActive is not None:
+            self.setIsAcceleratedConvergenceActive(IsAcceleratedConvergenceActive)
+        if AccelerateInitialStiffness is not None:
+            self.setAccelerateInitialStiffness(AccelerateInitialStiffness)
+        if AlphaMin is not None:
+            self.setAlphaMin(AlphaMin)
+        if AlphaMax is not None:
+            self.setAlphaMax(AlphaMax)
+        if AbortUponFailure is not None:
+            self.setAbortUponFailure(AbortUponFailure)
+        if EnableFileRecovery is not None:
+            self.setEnableFileRecovery(EnableFileRecovery)
+        if TensileFailureReduceHoekBrownTensileStrengthToZero is not None:
+            self.setTensileFailureReduceHoekBrownTensileStrengthToZero(TensileFailureReduceHoekBrownTensileStrengthToZero)
+        if TensileFailureReduceShearStrengthToResidual is not None:
+            self.setTensileFailureReduceShearStrengthToResidual(TensileFailureReduceShearStrengthToResidual)
+        if UseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion is not None:
+            self.setUseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion(UseDefaultMaterialForAdvancedMaterialsOutsidePlasticRegion)
+
+################ Code below this line will not be overridden ################
+from ._PropertyAccessor import StressAnalysisPropertyAccessor
+from rs3.projectSettings.ProjectSettingEnums import *
+class StressAnalysis(StressAnalysisBase):
+    """
+    Customize the parameters that control the finite element stress analysis in RS3.
+    
+    Examples:
+		See :ref:`project_settings_example`.
+    """
+    def __init__(self, client: Client, id: str):
+        super().__init__(client, id)
+        self._propertyAccessor = StressAnalysisPropertyAccessor(client, id)
+
+    def setLoadStepType(self, value : LoadStepType):
+        self._propertyAccessor.setEnumValue("load_step_type", value.value)
+    def getLoadStepType(self) -> LoadStepType:
+        return self._propertyAccessor.getEnumValue("load_step_type", LoadStepType)
+    def setConvergenceCriteriaType(self, value : StressConvergenceCriteriaType):
+        self._propertyAccessor.setEnumValue("Convergence", value.value)
+    def getConvergenceCriteriaType(self) -> StressConvergenceCriteriaType:
+        return self._propertyAccessor.getEnumValue("Convergence", StressConvergenceCriteriaType)

rs3/projectSettings/Units.py

@@ -0,0 +1,82 @@
+from rs3.projectSettings.ProjectSettingEnums import *
+from rs3._client import Client
+from ._PropertyAccessor import UnitsPropertyAccessor
+from rs3._proxyObject import _ProxyObject
+
+class Units(_ProxyObject):
+    """
+    Modify the units of a model.
+    
+    Examples:
+		See :ref:`project_settings_example`.
+    """
+    def __init__(self, client: Client, projectId: str):
+        super().__init__(client, projectId)
+        self._propertyAccessor = UnitsPropertyAccessor(client, projectId)
+        self.projectId = projectId
+        
+    def setUnitSystem(self, value : UnitSystemType, resetProperties : bool = True):
+        """
+        Sets the unit system for the current project.
+
+        By default, if the unit is changed, script will reset all unit-dependent
+        property values in the project to their default values. This will reset the 
+        Field Stress settings, and ALL properties for Material, Bolts, Liners, and Joints.
+        To preserve existing values when changing the unit, set `resetProperties` to False.
+
+        It is recommended to set the desired unit at the beginning of the script or project
+        to avoid unintended resets.
+
+        Parameters:
+            value (UnitSystemType): The unit system to apply.
+            resetProperties (bool, optional): Whether to reset unit-dependent property values to
+                their defaults. Defaults to True.
+        """
+        self._propertyAccessor.setEnumValue("Unit_System", value.value, resetProperties)
+        
+    def getUnitSystem(self) -> UnitSystemType:
+        return self._propertyAccessor.getEnumValue("Unit_System", UnitSystemType)
+    
+    def setTimeUnits(self, value : TimeUnitsType, resetProperties : bool = True):
+        """
+        Sets the time unit for the current project.
+
+        By default, if the unit is changed, script will reset all unit-dependent
+        property values in the project to their default values. This will reset the 
+        Field Stress settings, and ALL properties for Material, Bolts, Liners, and Joints.
+        To preserve existing values when changing the unit, set `resetProperties` to False.
+
+        It is recommended to set the desired unit at the beginning of the script or project
+        to avoid unintended resets.
+
+        Parameters:
+            value (TimeUnitsType): The unit system to apply.
+            resetProperties (bool, optional): Whether to reset unit-dependent property values to
+                their defaults. Defaults to True.
+        """
+        self._propertyAccessor.setEnumValue("TimeUnit", value.value, resetProperties)
+        
+    def getTimeUnits(self) -> TimeUnitsType:
+        return self._propertyAccessor.getEnumValue("TimeUnit", TimeUnitsType)
+    
+    def setPermeabilityUnits(self, value : PermeabilityUnitsType, resetProperties : bool = True):
+        """
+        Sets the permeability unit for the current project.
+
+        By default, if the unit is changed, script will reset all unit-dependent
+        property values in the project to their default values. This will reset the 
+        Field Stress settings, and ALL properties for Material, Bolts, Liners, and Joints.
+        To preserve existing values when changing the unit, set `resetProperties` to False.
+
+        It is recommended to set the desired unit at the beginning of the script or project
+        to avoid unintended resets.
+
+        Parameters:
+            value (PermeabilityUnitsType): The unit system to apply.
+            resetProperties (bool, optional): Whether to reset unit-dependent property values to
+                their defaults. Defaults to True.
+        """
+        self._propertyAccessor.setEnumValue("Permeability_Units", value.value, resetProperties)
+    
+    def getPermeabilityUnits(self) -> PermeabilityUnitsType:
+        return self._propertyAccessor.getEnumValue("Permeability_Units", PermeabilityUnitsType)

rs3/projectSettings/_PropertyAccessor.py

@@ -0,0 +1,133 @@
+from rs3.properties._PropertyAccessor import PropertyAccessor as BasePropertyAccessor
+import rs3.generatedFiles.ProjectSettingsDataService_pb2_grpc as ProjectSettingsDataService_pb2_grpc
+import rs3.generatedFiles.ProjectSettingsDataService_pb2 as ProjectSettingsDataService_pb2
+import rs3.generatedFiles.CommonMessages_pb2 as CommonMessages_pb2
+from rs3._client import Client
+class PropertyAccessor(BasePropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId, ProjectSettingsDataService_pb2_grpc.ProjectSettingsDataServiceStub(client.channel))
+        self._projectSettingsDataService = ProjectSettingsDataService_pb2_grpc.ProjectSettingsDataServiceStub(self._client.channel)
+        self.projectId = projectId
+
+class UnitsPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId)
+        
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue, resetProperties : bool):
+        request = ProjectSettingsDataService_pb2.SetProjectUnitRequest(objectId=self.projectId, 
+                                                        propertyName=propertyName,
+                                                        value=value,
+                                                        resetProperties=resetProperties)
+        self._client.callFunction(self._projectSettingsDataService.SetProjectUnits, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self.projectId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._projectSettingsDataService.GetProjectUnits, request)
+        return response.value
+
+    def setEnumValue(self, propertyName: str, value: str, resetProperties : bool):
+        self._setProperty(propertyName, CommonMessages_pb2.PropertyValue(enumValue=value), resetProperties)
+    
+class StagesPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId)
+        
+    def _setProperty(self, propertyName : str, stageNumber : int, value : CommonMessages_pb2.PropertyValue):
+        request = ProjectSettingsDataService_pb2.SetStagePropertyRequest(objectId=self.projectId, 
+                                                        propertyName=propertyName,
+                                                        stageNumber=stageNumber,
+                                                        value=value)
+        self._client.callFunction(self._projectSettingsDataService.SetStageProperties, request)
+        
+    def _getProperty(self, propertyName : str, stageNumber : int) -> CommonMessages_pb2.PropertyValue:
+        request = ProjectSettingsDataService_pb2.GetStagePropertyRequest(objectId=self.projectId, propertyName=propertyName, stageNumber=stageNumber)
+        response : ProjectSettingsDataService_pb2.GetStagePropertyResponse = self._client.callFunction(self._projectSettingsDataService.GetStageProperties, request)
+        return response.value
+    
+    def getDoubleProperty(self, propertyName : str, stageNumber: int) -> float:
+        return self._getProperty(propertyName, stageNumber).doubleValue
+
+    def setDoubleProperty(self, propertyName : str, stageNumber: int, value : float):
+        self._setProperty(propertyName, stageNumber, CommonMessages_pb2.PropertyValue(doubleValue=value))
+    
+    def getBoolValue(self, propertyName: str, stageNumber: int) -> bool:
+        return self._getProperty(propertyName, stageNumber).boolValue
+
+    def setBoolValue(self, propertyName: str, stageNumber: int, value: bool):
+        self._setProperty(propertyName, stageNumber, CommonMessages_pb2.PropertyValue(boolValue=value))
+        
+    def getStringValue(self, propertyName: str, stageNumber: int) -> str:
+        return self._getProperty(propertyName, stageNumber).stringValue
+
+    def setStringValue(self, propertyName: str, stageNumber: int, value: str):
+        self._setProperty(propertyName, stageNumber, CommonMessages_pb2.PropertyValue(stringValue=value))
+        
+    def getEnumValue(self, propertyName: str, stageNumber: int, enumType):
+        return enumType(self._getProperty(propertyName, stageNumber).enumValue)
+    
+    def setEnumValue(self, propertyName: str, stageNumber: int, value: str):
+        self._setProperty(propertyName, stageNumber, CommonMessages_pb2.PropertyValue(enumValue=value))
+    
+class StressAnalysisPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId)
+        
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetPropertyRequest(objectId=self.projectId, 
+                                                        propertyName=propertyName,
+                                                        value=value)
+        self._client.callFunction(self._projectSettingsDataService.SetStressAnalysis, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self.projectId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._projectSettingsDataService.GetStressAnalysis, request)
+        return response.value
+    
+class GroundwaterPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId)
+        
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetPropertyRequest(objectId=self.projectId, 
+                                                        propertyName=propertyName,
+                                                        value=value)
+        self._client.callFunction(self._projectSettingsDataService.SetGroundwater, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self.projectId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._projectSettingsDataService.GetGroundwater, request)
+        return response.value
+    
+class SSRPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId)
+        
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetPropertyRequest(objectId=self.projectId, 
+                                                        propertyName=propertyName,
+                                                        value=value)
+        self._client.callFunction(self._projectSettingsDataService.SetShearStrengthReduction, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self.projectId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._projectSettingsDataService.GetShearStrengthReduction, request)
+        return response.value
+    
+class DynamicPropertyAccessor(PropertyAccessor):
+    def __init__(self, client : Client, projectId : str):
+        super().__init__(client, projectId)
+        
+    def _setProperty(self, propertyName : str, value : CommonMessages_pb2.PropertyValue):
+        request = CommonMessages_pb2.SetPropertyRequest(objectId=self.projectId, 
+                                                        propertyName=propertyName,
+                                                        value=value)
+        self._client.callFunction(self._projectSettingsDataService.SetDynamic, request)
+        
+    def _getProperty(self, propertyName : str) -> CommonMessages_pb2.PropertyValue:
+        request = CommonMessages_pb2.GetPropertyRequest(objectId=self.projectId, propertyName=propertyName)
+        response : CommonMessages_pb2.GetPropertyResponse = self._client.callFunction(self._projectSettingsDataService.GetDynamic, request)
+        return response.value
+    
+    
+
+