RS2Scripting 11.23.0__py3-none-any.whl

rs2/interpreter/queryResults/TimeQueryResults.py

@@ -0,0 +1,111 @@
+class QueryPointResult:
+        def __init__(self, x_location, y_location, time, value):
+            self.x_location = x_location
+            self.y_location = y_location
+            self.time = time
+            self.value = value
+        
+        def GetXCoordinate(self) -> float:
+            '''
+            Returns the X-Coordinate of the query point
+            '''
+            return self.x_location
+    
+        def GetYCoordinate(self) -> float:
+            '''
+            Returns the Y-Coordinate of the query point
+            '''
+            return self.y_location
+
+        def GetStageTime(self) -> float:
+            '''
+            Returns the dynamic stage time of the query point
+            '''
+            return self.time
+        
+        def GetValue(self) -> float:
+            '''
+            Returns the value of the time query point
+            '''
+            return self.value
+
+class QueryLineResult:
+    def __init__(self, list_node_values):
+        list_node_value_obj = []
+        for node_value in list_node_values:
+            list_node_value_obj.append(QueryPointResult(*node_value))
+        self.query_values = list_node_value_obj
+    
+    def GetNodeValues(self) -> list[QueryPointResult]:
+        '''
+        | Returns a list[QueryPointResult] representing result at this node part of the time query line
+        | To get the x-coordinate, y-coordinate, dynamic stage time, or value, please call the supporting class methods:
+
+        * QueryPointResult.GetXCoordinate()
+        * QueryPointResult.GetYCoordinate()
+        * QueryPointResult.GetStageTime()
+        * QueryPointResult.GetValue()
+        '''
+        return self.query_values
+
+class TimeQueryPointResults:
+    # Stores all time query points result for specific stage
+    def __init__(self, entity_ID, query_point_values):
+        self.entity_ID = entity_ID
+        # Construct QueryPointResult objects
+        query_values_obj = []
+        for value in query_point_values:
+            query_values_obj.append(QueryPointResult(*value))
+        self.query_values = query_values_obj
+    
+    def GetUniqueIdentifier(self) -> int:
+        '''
+        Returns the unique identifier for the time query point
+        '''
+        return self.entity_ID
+    
+    def GetAllValues(self) -> list[QueryPointResult]:
+        '''
+        | Returns a list[QueryPointResult] representing result at all nodes of the time query point
+        | To get the x-coordinate, y-coordinate, dynamic stage time, or value, please call the supporting class methods:
+
+        * QueryPointResult.GetXCoordinate()
+        * QueryPointResult.GetYCoordinate()
+        * QueryPointResult.GetStageTime()
+        * QueryPointResult.GetValue()
+        '''
+        return self.query_values
+
+class TimeQueryLineResults:
+    # Stores all time query line result for specific stage
+    def __init__(self, entity_ID, list_query_line_data):
+        self.entity_ID = entity_ID
+        # Construct QueryPointResult objects
+        list_query_line_obj = []
+        for list_line_node_data in list_query_line_data:
+            list_query_line_obj.append(QueryLineResult(list_line_node_data))
+        self.line_data = list_query_line_obj
+    
+    def GetUniqueIdentifier(self) -> int:
+        '''
+        Returns the unique identifier for the time query point
+        '''
+        return self.entity_ID
+    
+    def GetAllNodeObjects(self) -> list[QueryLineResult]:
+        '''
+        Returns a list[QueryLineResult] representing nodes making up the time query line
+
+        To get list of node values associated with a specific node, please call the supported class method:
+
+        * QueryLineResult.GetNodeValues()
+
+        | The above returns a list[QueryPointResult] representing result at this node part of the time query line
+        | To get the x-coordinate, y-coordinate, dynamic stage time, or value, please call the supporting class methods:
+        
+        * QueryPointResult.GetXCoordinate()
+        * QueryPointResult.GetYCoordinate()
+        * QueryPointResult.GetStageTime()
+        * QueryPointResult.GetValue()
+        '''
+        return self.line_data

rs2/interpreter/supportResults/BoltResult.py

@@ -0,0 +1,49 @@
+from enum import Enum
+from rs2.interpreter._UtilityResult import *
+
+class BoltElementYieldStatus(Enum):
+    BOLT_ELEMENT_NOT_YIELDED = 0
+    BOLT_ELEMENT_TYPE_UNKNOWN_YIELDED  = 1
+    BOLT_ELEMENT_TENSION_YIELDED = 2
+    BOLT_ELEMENT_SHEAR_YIELDED  = 4
+    BOLT_ELEMENT_TENSIONANDSHEAR_YIELDED = BOLT_ELEMENT_TENSION_YIELDED + BOLT_ELEMENT_SHEAR_YIELDED
+    BOLT_ELEMENT_UNDEFINED_YIELDED = -1
+  
+class BoltYieldingResult:
+    def __init__(self, start_x, start_y, end_x, end_y, yielding_flag):
+        self.start_x = start_x #0
+        self.start_y = start_y #1
+        self.end_x = end_x #2
+        self.end_y = end_y #3
+        self.yielding_flag = BoltElementYieldStatus(yielding_flag) #4
+        ResetInvalid.validate(self)
+
+
+class BoltForceDisplacementResult:
+    def __init__(self, location_x, location_y, distance, axial_force, axial_stress, shear_force, rock_displacement, bolt_displacement):
+        self.location_x = location_x #0
+        self.location_y = location_y #1
+        self.distance = distance #2
+        self.axial_force = axial_force #3
+        self.axial_stress = axial_stress #4
+        self.shear_force = shear_force #5
+        self.rock_displacement = rock_displacement #6
+        self.bolt_displacement = bolt_displacement #7
+        ResetInvalid.validate(self)
+
+class BoltResult:
+    def __init__(self, entity_id, entity_data, yielding_results: BoltYieldingResult, force_displacement_results: BoltForceDisplacementResult):
+        if len(entity_data) == 0 or len(entity_data[0]) == 0:
+            assert False, 'location not defined'
+            return
+        location_tensor = entity_data[0][0]
+        start_x, start_y, end_x, end_y = location_tensor
+
+        self.entity_id = entity_id
+        self.start_x = start_x
+        self.start_y = start_y
+        self.end_x = end_x
+        self.end_y = end_y
+        self.yielding_results: BoltYieldingResult = yielding_results
+        self.force_displacement_results: BoltForceDisplacementResult = force_displacement_results
+

rs2/interpreter/supportResults/CompositeResult.py

@@ -0,0 +1,24 @@
+from rs2.interpreter.supportResults.LinerResult import LinerResult
+from rs2.interpreter.supportResults.JointResult import JointResult
+
+class PileResult:
+    def __init__(self, entity_id, joint_result: JointResult, liner_result: LinerResult):
+        self.entity_id = entity_id
+        self.joint_result: JointResult = joint_result
+        self.liner_result: LinerResult = liner_result
+
+class CompositeResult:
+    def __init__(self, entity_id, joint_result: JointResult, liner_result: LinerResult):
+        self.entity_id = entity_id
+        self.joint_result: JointResult = joint_result
+        self.liner_result: LinerResult = liner_result
+
+class StructuralResult:
+    def __init__(self, entity_id, joint_result: JointResult, liner_result: LinerResult):
+        self.entity_id = entity_id
+        self.joint_result: JointResult = joint_result
+        self.liner_result: LinerResult = liner_result
+
+
+
+

rs2/interpreter/supportResults/JointResult.py

@@ -0,0 +1,25 @@
+from rs2.interpreter._UtilityResult import *
+
+class JointElementResult:
+    def __init__(self, start_x, start_y, end_x, end_y, distance, normal_stress, shear_stress,confining_stress, normal_displacement, shear_displacement, yielded):
+        self.start_x = start_x
+        self.start_y = start_y
+        self.end_x = end_x
+        self.end_y = end_y
+        self.distance = distance
+        self.normal_stress = normal_stress
+        self.shear_stress = shear_stress
+        self.confining_stress = confining_stress
+        self.normal_displacement = normal_displacement
+        self.shear_displacement = shear_displacement
+        self.yielded = bool(yielded)
+        ResetInvalid.validate(self)
+
+class JointResult:
+    def __init__(self, entity_id, joint_element_results: JointElementResult):
+        self.entity_id = entity_id
+        self.joint_element_results: JointElementResult = joint_element_results
+
+
+
+

rs2/interpreter/supportResults/LinerResult.py

@@ -0,0 +1,33 @@
+from rs2.interpreter._UtilityResult import *
+
+class LinerElementResult:
+    def __init__(self,composite_layer, node_start, node_end, start_x, start_y, end_x, end_y, distance,axial_force, moment1, moment_mid, moment2, shear_force, displacement_total, displacement_x, displacement_y,
+                 axi_sym_force, axi_sym_moment,beam_yield,temperature):
+
+        self.composite_layer = int(composite_layer) #0
+        self.node_start = int(node_start) #1
+        self.node_end = int(node_end)#2
+        self.start_x = start_x#3
+        self.start_y = start_y#4
+        self.end_x = end_x#5
+        self.end_y = end_y#6
+        self.distance = distance#7
+
+        self.axial_force = axial_force#8
+        self.moment1 = moment1#9
+        self.moment_mid = moment_mid#10
+        self.moment2 = moment2#11
+        self.shear_force = shear_force#12
+        self.displacement_total = displacement_total#13
+        self.displacement_x = displacement_x#14
+        self.displacement_y = displacement_y#15
+        self.axi_sym_force = axi_sym_force#16
+        self.axi_sym_moment = axi_sym_moment#17
+        self.beam_yield = bool(beam_yield)#18
+        self.temperature = temperature#25
+        ResetInvalid.validate(self)
+
+class LinerResult:
+    def __init__(self, entity_id, liner_element_results: LinerElementResult):
+        self.entity_id = entity_id
+        self.liner_element_results: LinerElementResult = liner_element_results

rs2/modeler/Model.py

@@ -0,0 +1,350 @@
+from rs2.modeler.properties.bolt.Bolt import BoltProperty
+from rs2.modeler.properties.liner.Liner import LinerProperty
+from rs2.modeler.properties.joint.Joint import JointProperty
+from rs2.modeler.properties.pile.Pile import PileProperty
+from rs2.modeler.properties.StructuralInterface import StructuralInterfaceProperty
+from rs2.modeler.properties.CompositeProperty import CompositeProperty
+
+from rs2.modeler.properties.material.MaterialProperty import MaterialProperty
+from rs2.modeler.properties.ShearNormalFunction import ShearNormalFunction
+from rs2.modeler.properties.UserDefinedWaterMode import UserDefinedWaterMode
+from rs2.modeler.properties.DiscreteFunction import DiscreteFunction
+
+from rs2.BaseModel import BaseModel
+
+class Model(BaseModel):
+	"""
+	:ref:`Model Example`
+	"""
+	def getBoltPropertyByName(self, boltName : str) -> BoltProperty:
+		'''
+		|  Returns a Bolt Property object based on its name.
+		'''
+
+		boltObjectID = self._callFunction('getBoltPropertyByName', [boltName], keepReturnValueReference=True)
+		return BoltProperty(self._client, boltObjectID, self._documentProxy._ID)
+    
+	def getLinerPropertyByName(self, linerName : str) -> LinerProperty:
+		'''
+		|  Returns a Liner Property object based on its name.
+		'''
+		linerObjectID = self._callFunction('getLinerPropertyByName', [linerName], keepReturnValueReference=True)
+		return LinerProperty(self._client, linerObjectID, self._documentProxy._ID)
+	
+	def getJointPropertyByName(self, jointName : str) -> JointProperty:
+		'''
+		|  Returns a Joint Property object based on its name.
+		'''
+		jointObjectID = self._callFunction('getJointPropertyByName', [jointName], keepReturnValueReference=True)
+		return JointProperty(self._client, jointObjectID, self._documentProxy._ID)
+	
+	def getPilePropertyByName(self, pileName : str) -> PileProperty:
+		'''
+		|  Returns a Pile Property object based on its name.
+		'''
+		pileObjectID = self._callFunction('getPilePropertyByName', [pileName], keepReturnValueReference=True)
+		return PileProperty(self._client, pileObjectID, self._documentProxy._ID)
+
+	def getStructuralInterfacePropertyByName(self, structuralName : str) -> StructuralInterfaceProperty:
+		'''
+		|  Returns a Structural Interface Property object based on its name.
+		'''
+		structuralInterfaceObjectID = self._callFunction('getStructuralPropertyByName', [structuralName], keepReturnValueReference=True)
+		return StructuralInterfaceProperty(self._client, structuralInterfaceObjectID, self._documentProxy._ID)
+	
+	def getCompositeLinerPropertyByName(self, compositeName : str) -> CompositeProperty:
+		'''
+		|  Returns a Composite Liner Property object based on its name.
+		'''
+		compositeLinerObjectID = self._callFunction('getCompositePropertyByName', [compositeName], keepReturnValueReference=True)
+		return CompositeProperty(self._client, compositeLinerObjectID, self._documentProxy._ID)
+
+	def getMaterialPropertyByName(self, materialName : str) -> MaterialProperty:
+		'''
+		|  Returns a Material Property object based on its name.
+		'''
+		materialObjectID = self._callFunction('getMaterialPropertyByName', [materialName], keepReturnValueReference=True)
+		return MaterialProperty(self._client, materialObjectID, self._documentProxy._ID)
+
+	def getAllBoltProperties(self) -> list[BoltProperty]:
+
+		'''
+		|  Returns a list of all Bolt Property objects
+		'''
+		activeBoltProperties = []
+		boltObjectIDList = self._callFunction('getAllBoltProperties', [], keepReturnValueReference=True)
+		for boltObjectID in boltObjectIDList:
+			activeBoltProperties.append(BoltProperty(self._client, boltObjectID, self._documentProxy._ID))
+		return activeBoltProperties
+
+	def getAllLinerProperties(self) -> list[LinerProperty]:
+		'''
+		|  Returns a list of all Liner Property objects
+		'''
+		activeLinerProperties = []
+		linerObjectIDList = self._callFunction('getAllLinerProperties', [], keepReturnValueReference=True)
+		for linerObjectID in linerObjectIDList:
+			activeLinerProperties.append(LinerProperty(self._client, linerObjectID, self._documentProxy._ID))
+		return activeLinerProperties
+	
+	def getAllJointProperties(self) -> list[JointProperty]:
+		'''
+		|  Returns a list of all Joint Property objects
+		'''
+		activeJointProperties = []
+		jointObjectIDList = self._callFunction('getAllJointProperties', [], keepReturnValueReference=True)
+		for jointObjectID in jointObjectIDList:
+			activeJointProperties.append(JointProperty(self._client, jointObjectID, self._documentProxy._ID))
+		return activeJointProperties
+	
+	def getAllPileProperties(self) -> list[PileProperty]:
+		'''
+		|  Returns a list of all Pile Property objects
+		'''
+		activePileProperties = []
+		pileObjectIDList = self._callFunction('getAllPileProperties', [], keepReturnValueReference=True)
+		for pileObjectID in pileObjectIDList:
+			activePileProperties.append(PileProperty(self._client, pileObjectID, self._documentProxy._ID))
+		return activePileProperties
+	
+	def getAllStructuralInterfaceProperties(self) -> list[StructuralInterfaceProperty]:
+		'''
+		|  Returns a list of all Structural Interface Property objects
+		'''
+		activeStructuralProperties = []
+		structuralObjectIDList = self._callFunction('getAllStructuralProperties', [], keepReturnValueReference=True)
+		for structuralObjectID in structuralObjectIDList:
+			activeStructuralProperties.append(StructuralInterfaceProperty(self._client, structuralObjectID, self._documentProxy._ID))
+		return activeStructuralProperties
+	
+	def getAllCompositeLinerProperties(self) -> list[CompositeProperty]:
+		'''
+		|  Returns a list of all Composite Liner Property objects
+		'''
+		activeCompositeProperties = []
+		compositeObjectIDList = self._callFunction('getAllCompositeProperties', [], keepReturnValueReference=True)
+		for compositeObjectID in compositeObjectIDList:
+			activeCompositeProperties.append(CompositeProperty(self._client, compositeObjectID, self._documentProxy._ID))
+		return activeCompositeProperties
+	
+	def getAllMaterialProperties(self) -> list[MaterialProperty]:
+		'''
+		|  Returns a list of all Material Property objects
+		'''
+		activeMaterialProperties = []
+		materialObjectIDList = self._callFunction('getAllMaterialProperties', [], keepReturnValueReference=True)
+		for materialObjectID in materialObjectIDList:
+			activeMaterialProperties.append(MaterialProperty(self._client, materialObjectID, self._documentProxy._ID))
+		return activeMaterialProperties
+	
+	def getShearNormalFunctions(self) -> list[ShearNormalFunction]:
+		'''
+		|  Returns a list of all shear normal functions
+		'''
+		activeShearNormalFunctionProperties = []
+		shearNormalFunctionIDList = self._callFunction('getShearNormalFunctions', [], keepReturnValueReference=True)
+		for shearNormalFunctionObjectID in shearNormalFunctionIDList:
+			activeShearNormalFunctionProperties.append(ShearNormalFunction(self._client, shearNormalFunctionObjectID))
+		return activeShearNormalFunctionProperties
+	
+	def getShearNormalFunctionByName(self, shearNormalFunctionName : str) -> ShearNormalFunction:
+		'''
+		|  Returns a shear normal function object based on its name.
+		'''
+		shearNormalFunctionObjectID = self._callFunction('getShearNormalFunctionByName', [shearNormalFunctionName], keepReturnValueReference=True)
+		return ShearNormalFunction(self._client, shearNormalFunctionObjectID)
+	
+	def createNewShearNormalFunction(self, functionName):
+		'''
+		|  Creates a new shear normal function with the given name
+		'''
+		return self._callFunction('createNewShearNormalFunction', [functionName])
+	
+	def deleteShearNormalFunction(self, functionName):
+		'''
+		|  Deletes a shear normal function with the given name
+		'''
+		return self._callFunction('deleteShearNormalFunction', [functionName])
+	
+	def renameShearNormalFunction(self, oldName, newName):
+		'''
+		|  Renames a shear normal function with the given name
+		'''
+		return self._callFunction('renameShearNormalFunction', [oldName, newName])
+	
+	def getUserDefinedPermeabilityAndWaterContentMode(self, name : str) -> UserDefinedWaterMode:
+		'''
+		|  Returns a User Defined Water Mode object based on its name.
+		'''
+		userDefinedWaterModeObjectID = self._callFunction('getUserDefinedWaterMode', [name], keepReturnValueReference=True)
+		return UserDefinedWaterMode(self._client, userDefinedWaterModeObjectID)
+	
+	def createUserDefinedPermeabilityAndWaterContentMode(self, name : str) -> UserDefinedWaterMode:
+		'''
+		|  Creates a User Defined Water Mode object with the given name.
+		'''
+		userDefinedWaterModeObjectID = self._callFunction('createUserDefinedWaterMode', [name], keepReturnValueReference=True)
+		return UserDefinedWaterMode(self._client, userDefinedWaterModeObjectID)
+
+	def deleteUserDefinedPermeabilityAndWaterContentMode(self, name : str):
+		'''
+		|  Deletes a User Defined Water Mode object with the given name.
+		'''
+		return self._callFunction('deleteUserDefinedWaterMode', [name])
+	
+	def renameUserDefinedPermeabilityAndWaterContentMode(self, oldName : str, newName : str):
+		'''
+		|  Renames a User Defined Water Mode object with the given name.
+		'''
+		return self._callFunction('renameUserDefinedWaterMode', [oldName, newName])
+	
+	def AddHistoryQueryPoint(self, x: float, y: float, history_query_name: str):
+		'''
+		:ref:`History Query Example`
+
+		|  Add a new History Query point to your model with the specified coordinates and label name
+
+		'''
+		return self._callFunction('AddHistoryQueryPoint', [x, y, history_query_name])
+
+	def RemoveHistoryQueryPoint(self, history_query_name: str):
+		'''
+		:ref:`History Query Example`
+
+		|  Remove a History Query point from your model by label name.
+
+		'''
+		return self._callFunction('RemoveHistoryQueryPoint', [history_query_name])
+
+	def AddTimeQueryLine(self, points: list[list[float]], points_on_line: int) -> str:
+		'''
+		:ref:`Time Query Example`
+
+		|  Add a new Time Query Line to your model with the specified coordinates
+		
+		Warning:
+			points_on_line must be between 1 and 10 inclusive.
+
+		'''
+		return self._callFunction('AddTimeQueryLine', [points, points_on_line])
+	
+	def RemoveTimeQueryLine(self, IDs_toRemove: list[str]):
+		'''
+		:ref:`Time Query Example`
+
+		|  Removes Time Query Line(s) from your model using provided list of IDs.
+
+		'''
+		return self._callFunction('RemoveTimeQueryLine', [IDs_toRemove])
+	
+	def AddTimeQueryPoint(self, x: float, y: float) -> str:
+		'''
+		:ref:`Time Query Example`
+
+		|  Add a new Time Query Point to your model with the specified x and y coordinates
+
+		'''
+		return self._callFunction('AddTimeQueryPoint', [x, y])
+	
+	def RemoveTimeQueryPoint(self, IDs_toRemove: list[str]):
+		'''
+		:ref:`Time Query Example`
+		
+		|  Removes Time Query Point(s) from your model using provided list of IDs.
+
+		'''
+		return self._callFunction('RemoveTimeQueryPoint', [IDs_toRemove])
+	
+	def compute(self):
+		'''
+		|  Saves the file if modified and then runs compute. Replaces any existing results.
+
+		Warning:
+			All objects retrieved from the interpreter for this file will be invalidated after this call.
+			If you have an interpreter model open, you should close, compute, and then re-open the model.
+
+			.. code-block:: python
+
+				interpreterModel.close()
+				model.compute()
+				interpreterModel = modeler.openFile('C:/previouslyOpened.fez')
+				
+		'''
+		return self._callFunction('compute', [False])
+
+	def computeGroundWater(self):
+		'''
+		|  Saves the file if modified and then runs groundwater compute. Replaces any existing results.
+
+		Warning:
+			All objects retrieved from the interpreter for this file will be invalidated after this call.
+			If you have an interpreter model open, you should close, compute, and then re-open the model.
+
+			.. code-block:: python
+
+				interpreterModel.close()
+				model.compute()
+				interpreterModel = modeler.openFile('C:/previouslyOpened.fez')
+		'''
+		return self._callFunction('compute', [True])
+
+	def saveAs(self, fileName : str):
+		'''
+		|  Saves the model using the given file name.
+
+		Example:
+
+		.. code-block:: python
+
+			model.saveAs('C:/simple_3_stage.fez')
+		'''
+		formattedFileName = fileName.replace('/', '\\')
+		self._enforceFeaFezEnding(formattedFileName)
+		return self._callFunction('saveAs', [formattedFileName])
+
+	def getDiscreteFunctions(self) -> list[DiscreteFunction]:
+		'''
+		|  Returns a list of all discrete functions
+		'''
+		activeDiscreteFunctionProperties = []
+		discreteFunctionIDList = self._callFunction('getDiscreteFunctions', [], keepReturnValueReference=True)
+		for discreteFunctionObjectID in discreteFunctionIDList:
+			activeDiscreteFunctionProperties.append(DiscreteFunction(self._client, discreteFunctionObjectID))
+		return activeDiscreteFunctionProperties
+	
+	def getDiscreteFunctionByName(self, discreteFunctionName : str) -> DiscreteFunction:
+		'''
+		|  Returns a discrete function object based on its name.
+		'''
+		discreteFunctionObjectID = self._callFunction('getDiscreteFunctionByName', [discreteFunctionName], keepReturnValueReference=True)
+		return DiscreteFunction(self._client, discreteFunctionObjectID)
+	
+	def createNewDiscreteFunction(self, functionName):
+		'''
+		|  Creates a new discrete function with the given name
+		'''
+		return self._callFunction('createNewDiscreteFunction', [functionName])
+	
+	def deleteDiscreteFunction(self, functionName):
+		'''
+		|  Deletes a discrete function with the given name
+		'''
+		return self._callFunction('deleteDiscreteFunction', [functionName])
+	
+	def renameDiscreteFunction(self, oldName, newName):
+		'''
+		|  Renames a discrete function with the given name
+		'''
+		return self._callFunction('renameDiscreteFunction', [oldName, newName])	
+	
+
+
+	def ResetProperties(self):
+		'''
+		:ref:`Get Model Units Example`
+
+		|  Reset all properties for your model
+
+		'''
+		return self._callFunction('ResetProperties', [])
+	

rs2/modeler/RS2Modeler.py

@@ -0,0 +1,81 @@
+from rsmessages.requestFormat import functionRequest
+from rs2._common.Client import Client
+from rs2.modeler.Model import Model
+from rs2.utilities.ApplicationManager import ApplicationManager
+import winreg
+import time
+
+class RS2Modeler:
+	"""
+	:ref:`Modeler Example`
+	"""
+	def __init__(self, host='localhost', port=60054):
+		self.client = Client(host, port)
+
+	def openFile(self, fileName : str) -> Model:
+		'''
+		Takes in the absolute path to an rs2 file to be opened in the modeler.
+
+		Example:
+
+		.. code-block:: python
+
+			model = modeler.openFile('C:/simple_3_stage.fez')
+		'''
+		request = functionRequest('open_file', [fileName], keepReturnValueReference=True)
+		modelObjectId = self.client.callFunction(request)
+		model = Model(self.client, modelObjectId)
+		return model
+
+	@classmethod
+	def startApplication(cls, port : int, overridePathToExecutable : str = None, timeout : float = 30) -> None:
+		"""Opens the most recently installed RS2 application. Starts the python server and binds it to the given port.
+
+		Args:
+			port (int): the port to bind the python server to. Use this same port when initializing RS2Modeler
+			overridePathToExecutable (str, optional): full path to the desired executable to be opened. If not provided, the latest installation of rs2 is used
+			timeout (float, optional): the maximum amount of time to wait for the application and server to start.
+		
+		Raises:
+			ValueError: Port range must be between 49152 and 65535, otherwise ValueError is raised
+			TimeoutError: if timeout is provided, raises TimeoutError if not able to connect to the server within that time.
+		"""
+		appManager = ApplicationManager()
+		executablePath = overridePathToExecutable if overridePathToExecutable else cls._getApplicationPath()
+		appManager.startApplication(executablePath, port, timeout)
+
+	@staticmethod
+	def _getApplicationPath() -> str:
+
+		registry = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+		key = winreg.OpenKey(registry, r'SOFTWARE\Rocscience\RS2 11.0')
+		installationLocation, type = winreg.QueryValueEx(key, "Install")
+
+		rs2ModelerInstallLocation =  rf"{installationLocation}\RS2"
+
+		return rs2ModelerInstallLocation
+	
+	def closeProgram(self, saveModels=True, timeout=30):
+		'''
+		Closes the modeler program. All unsaved models are saved by default.
+
+		Example:
+
+		.. code-block:: python
+
+			#saves all models before closing
+			modeler.closeProgram(True)
+
+			#closes the program without saving
+			modeler.closeProgram(False)
+		'''
+		request = functionRequest('closeProgram', [saveModels])
+		portUsed = self.client.callFunction(request)
+		self.client.closeConnection()
+		appManager = ApplicationManager()
+		portIsAvailable = False
+		startTime = time.time()
+		while not portIsAvailable:
+			if (time.time() - startTime) > timeout:
+				raise TimeoutError("The application did not close within the given timeout time.")
+			portIsAvailable = appManager._isPortAvailable(portUsed)