RS3Scripting 4.42.0__py3-none-any.whl

rs3/ModelEnums.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class ComputeType(Enum):
+    ALL = "ALL"
+    GROUNDWATER_ONLY = "GW_ONLY"
+    
+class ComputeStart(Enum):
+    AFTER_LAST_COMPUTED_STAGE = "AFTER_LAST_COMPUTED_STAGE"
+    FROM_BEGINNING = "FROM_BEGINNING"

rs3/RS3Modeler.py

@@ -0,0 +1,109 @@
+# Generated by RPCBinder in RFC_Common.
+import rs3.generatedFiles.RS3ModelerService_pb2_grpc as RS3ModelerServiceGrpc
+import rs3.generatedFiles.RS3ModelerService_pb2 as RS3ModelerService
+from rs3._client import Client
+
+class RS3ModelerBase:
+    def __init__(self, client: Client):
+        self._client = client
+        self._RS3ModelerService = RS3ModelerServiceGrpc.RS3ModelerServiceStub(self._client.channel)
+    def openFile(self, path: str) -> str:
+        path_ = path
+        request = RS3ModelerService.openFileRequest(path=path_)
+        result_ = self._client.callFunction(self._RS3ModelerService.openFile, request)
+        result = result_.result
+        return result
+    
+    def closeProgram(self, saveModels: bool) -> int:
+        saveModels_ = saveModels
+        request = RS3ModelerService.closeProgramRequest(saveModels=saveModels_)
+        result_ = self._client.callFunction(self._RS3ModelerService.closeProgram, request)
+        result = result_.result
+        return result
+    
+    def _isViewLoaded(self, path: str) -> bool:
+        path_ = path
+        request = RS3ModelerService._isViewLoadedRequest(path=path_)
+        result_ = self._client.callFunction(self._RS3ModelerService._isViewLoaded, request)
+        result = result_.result
+        return result
+    
+def RS3ModelerBase2RS3ModelerRS3ModelerBase(a: RS3ModelerBase) -> RS3ModelerService.RS3ModelerBase:
+    result = RS3ModelerService.RS3ModelerBase()
+    return result
+
+def RS3ModelerRS3ModelerBase2RS3ModelerBase(client: Client, a: RS3ModelerService.RS3ModelerBase) -> RS3ModelerBase:
+    result = RS3ModelerBase(client)
+    return result
+
+
+################ Code below this line will not be overridden ################
+import rs3.generatedFiles.RFCApplicationService_pb2 as RFCApplicationService_pb2
+import rs3.generatedFiles.RFCApplicationService_pb2_grpc as RFCApplicationService_pb2_grpc
+from rs3.ApplicationManager import ApplicationManager
+from rs3.Model import Model
+from rs3.ColorPicker import *
+import winreg
+import logging
+import time
+
+class RS3Modeler(RS3ModelerBase):
+    def __init__(self, port=60064):
+        super().__init__(Client(port))
+        
+    def openFile(self, path: str) -> Model:
+        projectId = super().openFile(path)
+        while(not self._isViewLoaded(path)):
+            time.sleep(0.5)   
+        return Model(self._client, projectId)
+    
+    @classmethod
+    def startApplication(cls, port : int, overridePathToExecutable : str = None, timeout : float = 120) -> None:
+        """Opens the most recently installed RS3 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 RS3Modeler
+            overridePathToExecutable (str, optional): full path to the desired executable to be opened. If not provided, the latest installation of rs3 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()
+
+        logger = logging.getLogger('Rocscience.RS3')
+        appManager.startApplication(executablePath, port, cls._isServerRunning, logger, timeout)
+
+    def closeProgram(self, saveModels = True, timeout : float = 120) -> None:
+        portUsed = super().closeProgram(saveModels)
+        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)
+   
+    @staticmethod
+    def _getApplicationPath() -> str:
+
+        registry = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+        key = winreg.OpenKey(registry, r'SOFTWARE\Rocscience\RS3 4.0')
+        installationLocation, type = winreg.QueryValueEx(key, "Install")
+
+        rs3ModelerInstallLocation =  rf"{installationLocation}\RS3"
+
+        return rs3ModelerInstallLocation
+    
+    @staticmethod
+    def _isServerRunning(port) -> bool:
+        client = Client(port)
+        stub = RFCApplicationService_pb2_grpc.RFCApplicationServiceStub(client.channel)
+        pingRequest = RFCApplicationService_pb2.PingRequest()
+        client.callFunction(stub.Ping, pingRequest)
+
+        client.closeConnection()
+        return True

rs3/Restraints.py

@@ -0,0 +1,91 @@
+# Generated by RPCBinder in RFC_Common.
+import rs3.generatedFiles.RestraintsService_pb2_grpc as RestraintsServiceGrpc
+import rs3.generatedFiles.RestraintsService_pb2 as RestraintsService
+from rs3._client import Client
+
+class RestraintsBase:
+    def __init__(self, client: Client, _projectId: str):
+        self._client = client
+        self._projectId = _projectId
+        self._RestraintsService = RestraintsServiceGrpc.RestraintsServiceStub(self._client.channel)
+    def setAutoRestraints(self, autoRestraintTypeValue: int) -> None:
+        _projectId_ = self._projectId
+        autoRestraintTypeValue_ = autoRestraintTypeValue
+        request = RestraintsService.setAutoRestraintsRequest(_projectId=_projectId_, autoRestraintTypeValue=autoRestraintTypeValue_)
+        self._client.callFunction(self._RestraintsService.setAutoRestraints, request)
+    
+    def deleteAllRestraints(self) -> None:
+        _projectId_ = self._projectId
+        request = RestraintsService.deleteAllRestraintsRequest(_projectId=_projectId_)
+        self._client.callFunction(self._RestraintsService.deleteAllRestraints, request)
+    
+    def getIsRestraintsSet(self) -> bool:
+        _projectId_ = self._projectId
+        request = RestraintsService.getIsRestraintsSetRequest(_projectId=_projectId_)
+        result_ = self._client.callFunction(self._RestraintsService.getIsRestraintsSet, request)
+        result = result_.result
+        return result
+    
+    def setResetAllDisplacements(self, resetDisplacementsAfterStages: bool, stageNames: list[str]) -> None:
+        _projectId_ = self._projectId
+        resetDisplacementsAfterStages_ = resetDisplacementsAfterStages
+        stageNames_ = stageNames
+        request = RestraintsService.setResetAllDisplacementsRequest(_projectId=_projectId_, resetDisplacementsAfterStages=resetDisplacementsAfterStages_, stageNames=stageNames_)
+        self._client.callFunction(self._RestraintsService.setResetAllDisplacements, request)
+    
+    def getIsResetAllDisplacementsAfterStages(self) -> bool:
+        _projectId_ = self._projectId
+        request = RestraintsService.getIsResetAllDisplacementsAfterStagesRequest(_projectId=_projectId_)
+        result_ = self._client.callFunction(self._RestraintsService.getIsResetAllDisplacementsAfterStages, request)
+        result = result_.result
+        return result
+    
+    def getResetAllDisplacementsStages(self) -> list[str]:
+        _projectId_ = self._projectId
+        request = RestraintsService.getResetAllDisplacementsStagesRequest(_projectId=_projectId_)
+        result_ = self._client.callFunction(self._RestraintsService.getResetAllDisplacementsStages, request)
+        result = [obj for obj in result_.result]
+        return result
+    
+def RestraintsBase2RestraintsRestraintsBase(a: RestraintsBase) -> RestraintsService.RestraintsBase:
+    result = RestraintsService.RestraintsBase(_projectId=a._projectId)
+    return result
+
+def RestraintsRestraintsBase2RestraintsBase(client: Client, a: RestraintsService.RestraintsBase) -> RestraintsBase:
+    result = RestraintsBase(client, a._projectId)
+    return result
+
+
+################ Code below this line will not be overridden ################
+from rs3.CommonEnums import *
+class Restraints(RestraintsBase):
+    """
+    Examples:
+        See :ref:`restraints_example`.
+    """ 
+    def __init__(self, client: Client, projectId: str):
+        super().__init__(client, projectId)
+        
+    def setAutoRestraints(self, autoRestraintType : AutoRestraintsType):
+        """
+        Automatically restrain the external surfaces in the chosen type.
+        """
+        super().setAutoRestraints(autoRestraintType.value)
+        
+    def setResetAllDisplacements(self, resetDisplacementsAfterStages: bool, stageNames: list[str] = None):
+        """
+        Reset all calculated displacements to zero after any stage. 
+        
+        Parameters:
+            - resetDisplacementsAfterStages (bool): allow to reset displacement after stages.
+            - stageNames (str): the name of stages that will be reset.
+        
+        Example:
+            >>> model.Restraints.setResetAllDisplacements(True, ["Stage 1", "Stage 5", "Stage 2"])
+            >>> model.Restraints.setResetAllDisplacements(False)
+        
+        """
+        super().setResetAllDisplacements(resetDisplacementsAfterStages, stageNames)
+        
+    def getResetAllDisplacements(self) -> tuple[bool, list[str]]:
+        return (super().getIsResetAllDisplacementsAfterStages(), super().getResetAllDisplacementsStages())

rs3/Selection.py

@@ -0,0 +1,123 @@
+import rs3.generatedFiles.SelectionService_pb2_grpc as SelectionServiceGrpc
+import rs3.generatedFiles.SelectionService_pb2 as SelectionService
+from rs3._client import Client
+from rs3.ExternalVolume import ExternalVolume
+from rs3.Geometry import *
+from typing import Union
+
+class Selection:
+    def __init__(self, client: Client, projectId: str):
+        self._client = client
+        self._projectId = projectId
+        self._SelectionService = SelectionServiceGrpc.SelectionServiceStub(self._client.channel)
+
+    def _getExternalVolumesByPoint(self, point: Point) -> list[str]:
+        _projectId_ = self._projectId
+        geometry_ = point.toCommonGeometryObject()
+        request = SelectionService._getExternalVolumesByGeometryRequest(_projectId=_projectId_, geometry=geometry_, includeIntersecting=False)
+        result_ = self._client.callFunction(self._SelectionService._getExternalVolumesByPoint, request)
+        result = [obj for obj in result_.result]
+        return result
+
+    def _getExternalVolumesByPolyline(self, polyline: Polyline) -> list[str]:
+        _projectId_ = self._projectId
+        geometry_ = polyline.toCommonGeometryObject()
+        request = SelectionService._getExternalVolumesByGeometryRequest(_projectId=_projectId_, geometry=geometry_, includeIntersecting=False)
+        result_ = self._client.callFunction(self._SelectionService._getExternalVolumesByPolyline, request)
+        result = [obj for obj in result_.result]
+        return result
+
+    def _getExternalVolumesByBoundingVolume(self, volume: Union[Cube, Cylinder, Sphere], includeIntersecting: bool) -> list[str]:
+        _projectId_ = self._projectId
+        includeIntersecting_ = includeIntersecting
+        geometry_ = volume.toCommonGeometryObject()
+        request = SelectionService._getExternalVolumesByGeometryRequest(_projectId=_projectId_, geometry=geometry_, includeIntersecting=includeIntersecting_)
+        result_ = self._client.callFunction(self._SelectionService._getExternalVolumesByBoundingVolume, request)
+        result = [obj for obj in result_.result]
+        return result
+
+    def getExternalVolumes(self, sampleRegion : Geometry, includeIntersecting : bool = True) -> list[ExternalVolume]:
+        """
+        Retrieve external volumes that intersect with or are contained within a specified geometric region.
+
+        This method performs spatial queries to find external volumes based on different geometric
+        sample regions. The function supports various geometric shapes and can optionally include
+        or exclude volumes that only partially intersect with the sample region.
+
+        Args:
+            sampleRegion (Geometry): The geometric region to use for volume selection. Supported types:
+                - Point: Selects volumes containing the specified point
+                - Polyline: Selects volumes intersecting with the polyline path
+                - Cube: Selects volumes within or intersecting the bounding box defined by two corner points
+                - Cylinder: Selects volumes within or intersecting the cylindrical region
+                - Sphere: Selects volumes within or intersecting the spherical region
+            includeIntersecting (bool, optional): Whether to include volumes that only partially
+                intersect with the sample region. Defaults to True.
+                - True: Returns volumes that are fully contained within OR partially intersect the region
+                - False: Returns only volumes that are fully contained within the region
+
+                Note: This parameter only applies to Cube, Cylinder, and Sphere geometry types.
+                For Point and Polyline, this parameter is ignored as the selection behavior
+                is inherently based on intersection/containment.
+
+        Returns:
+            list[ExternalVolume]: A list of ExternalVolume objects that match the selection criteria.
+            Returns an empty list if no volumes are found.
+
+        Raises:
+            TypeError: If sampleRegion is not one of the supported Geometry types.
+
+        Examples:
+            See :ref:`external_volume_and_selection_example`.
+
+        >>> # Select volumes containing a specific point
+        >>> point = Point(20.0, 0.0, -50.0)
+        >>> volumes = selection.getExternalVolumes(point)
+
+        >>> # Select volumes intersecting with a polyline
+        >>> polyline = Polyline([Point(5.5, -40, -50), Point(25, 5.2, -48), Point(20.5, 50.2, -45)])
+        >>> volumes = selection.getExternalVolumes(polyline)
+
+        >>> # Select volumes within a bounding box (including intersecting)
+        >>> cube = Cube(Point(18.0, 1.5, -49.2), Point(23.5, 2.5, -47.3))
+        >>> volumes = selection.getExternalVolumes(cube, includeIntersecting=True)
+
+        >>> # Select only volumes fully contained within a bounding box
+        >>> volumes = selection.getExternalVolumes(cube, includeIntersecting=False)
+
+        >>> # Select volumes within a cylindrical region
+        >>> cylinder = Cylinder(Point(22.12, 45.3, -52.2), Point(25.2, 30.3, -48.4), radius=1.0)
+        >>> volumes = selection.getExternalVolumes(cylinder)
+
+        >>> # Select volumes within a spherical region
+        >>> sphere = Sphere(Point(18.94, 47.05, -53.83), radius=5.0)
+        >>> volumes = selection.getExternalVolumes(sphere)
+        """
+        if isinstance(sampleRegion, Point):
+            externalVolumes = self._getExternalVolumesByPoint(point=sampleRegion)
+        elif isinstance(sampleRegion, Polyline):
+            externalVolumes = self._getExternalVolumesByPolyline(polyline=sampleRegion)
+        elif isinstance(sampleRegion, Cube) or isinstance(sampleRegion, Cylinder) or isinstance(sampleRegion, Sphere):
+            externalVolumes = self._getExternalVolumesByBoundingVolume(volume=sampleRegion, includeIntersecting=includeIntersecting)
+        else:
+            raise TypeError(f"Unsupported SampleRegion type: {type(sampleRegion)}")
+
+        return [ExternalVolume(self._client, obj) for obj in externalVolumes]
+
+    def getAttachedExternalVolumes(self, externalVolume : ExternalVolume) -> list[ExternalVolume]:
+        """
+        Examples:
+            See :ref:`external_volume_and_selection_example`.
+        """
+        request = SelectionService.getAttachedExternalVolumesRequest(_projectId=self._projectId, _externalVolumeID=externalVolume._objectId)
+        result_ = self._client.callFunction(self._SelectionService.getAttachedExternalVolumes, request)
+        return [ExternalVolume(self._client, obj) for obj in result_.result]
+
+    def getAttachedExternalVolumesByVolumeName(self, externalVolumeName : str) -> list[ExternalVolume]:
+        """
+        Examples:
+            See :ref:`external_volume_and_selection_example`.
+        """
+        request = SelectionService.getAttachedExternalVolumesByVolumeNameRequest(_projectId=self._projectId, externalVolumeName=externalVolumeName)
+        result_ = self._client.callFunction(self._SelectionService.getAttachedExternalVolumesByVolumeName, request)
+        return [ExternalVolume(self._client, obj) for obj in result_.result]

rs3/__init__.py

@@ -0,0 +1,18 @@
+import logging
+
+# create logger
+logger = logging.getLogger('Rocscience.RS3')
+logger.setLevel(logging.INFO)
+
+# create console handler and set level to debug
+ch = logging.StreamHandler()
+ch.setLevel(logging.INFO)
+
+# create formatter
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+# add formatter to ch
+ch.setFormatter(formatter)
+
+# add ch to logger
+logger.addHandler(ch)

rs3/_client.py

@@ -0,0 +1,57 @@
+import grpc
+import logging
+import atexit
+import rs3.generatedFiles.ClientService_pb2_grpc as ClientService_pb2_grpc
+import rs3.generatedFiles.ClientService_pb2 as ClientService_pb2
+
+class Client:
+    def __init__(self, port):
+        self.compatibleProgramVersion = "4.042"
+        self.connection = self._establishConnection(port)
+        self.logger = logging.getLogger('Rocscience.RS3')
+        atexit.register(self.closeConnection)
+        
+        clientService = ClientService_pb2_grpc.ClientServiceStub(self.channel)
+        request = ClientService_pb2._GetProgramVersionRequest()
+        versionCompatible = self.callFunction(clientService._GetProgramVersion, request).result
+        if self.compatibleProgramVersion != versionCompatible:
+            self.closeConnection()
+            raise RuntimeError(f"""
+					  Library version is not compatible with the program version. 
+					  Please ensure the versions match by installing the correct version of the library or program. 
+					  Library version: {self.compatibleProgramVersion} Program version: find in help->about.
+					  """
+					  )
+        
+    def _establishConnection(self, port):
+        self.channel = grpc.insecure_channel(f"localhost:{port}")
+
+    def closeConnection(self):
+        if self.channel:
+            self.channel.close()
+            self.channel = None
+
+    def callFunction(self, function, request):
+        try:
+            response, call = function.with_call(request)
+            self._logMessages(call)
+            return response
+        except grpc.RpcError as e:
+            self.logger.exception("An exception was raised from the application.")
+            raise
+            
+    def _logMessages(self, call):
+        if not call:
+            return
+        
+        for key, value in call.trailing_metadata():
+            # Decode bytes to string if needed
+            if isinstance(value, bytes):
+                value = value.decode('utf-8')
+            
+            if key == "warning-bin":
+                self.logger.warning(value)
+            if key == "info-bin":
+                self.logger.info(value)
+            if key == "debug-bin":
+                self.logger.debug(value)

rs3/_proxyObject.py

@@ -0,0 +1,5 @@
+from rs3._client import Client
+class _ProxyObject():
+    def __init__(self, client: Client, objectId: str):
+        self._client = client
+        self._objectId = objectId

rs3/generatedFiles/BFPCommonMessage_pb2.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: BFPCommonMessage.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'BFPCommonMessage.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x42\x46PCommonMessage.proto\x12\x10\x42\x46PCommonMessage\"\xeb\x01\n\x12\x45lementNodalValues\x12\x11\n\taxisForce\x18\x01 \x01(\x01\x12\x19\n\x11shearForceMinAxis\x18\x02 \x01(\x01\x12\x19\n\x11shearForceMaxAxis\x18\x03 \x01(\x01\x12\x15\n\rmomentMinAxis\x18\x04 \x01(\x01\x12\x15\n\rmomentMaxAxis\x18\x05 \x01(\x01\x12\x15\n\rdisplacementX\x18\x06 \x01(\x01\x12\x15\n\rdisplacementY\x18\x07 \x01(\x01\x12\x15\n\rdisplacementZ\x18\x08 \x01(\x01\x12\x19\n\x11totalDisplacement\x18\t \x01(\x01\"\xeb\x01\n\x14InterfaceNodalValues\x12\x12\n\nshearForce\x18\x01 \x01(\x01\x12\x1a\n\x12normalForceMinAxis\x18\x02 \x01(\x01\x12\x1a\n\x12normalForceMaxAxis\x18\x03 \x01(\x01\x12\x17\n\x0f\x63onfiningStress\x18\x04 \x01(\x01\x12\x19\n\x11rockDisplacementX\x18\x05 \x01(\x01\x12\x19\n\x11rockDisplacementY\x18\x06 \x01(\x01\x12\x19\n\x11rockDisplacementZ\x18\x07 \x01(\x01\x12\x1d\n\x15rockTotalDisplacement\x18\x08 \x01(\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'BFPCommonMessage_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_ELEMENTNODALVALUES']._serialized_start=45
+  _globals['_ELEMENTNODALVALUES']._serialized_end=280
+  _globals['_INTERFACENODALVALUES']._serialized_start=283
+  _globals['_INTERFACENODALVALUES']._serialized_end=518
+# @@protoc_insertion_point(module_scope)

rs3/generatedFiles/BFPCommonMessage_pb2.pyi

@@ -0,0 +1,47 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class ElementNodalValues(_message.Message):
+    __slots__ = ("axisForce", "shearForceMinAxis", "shearForceMaxAxis", "momentMinAxis", "momentMaxAxis", "displacementX", "displacementY", "displacementZ", "totalDisplacement")
+    AXISFORCE_FIELD_NUMBER: _ClassVar[int]
+    SHEARFORCEMINAXIS_FIELD_NUMBER: _ClassVar[int]
+    SHEARFORCEMAXAXIS_FIELD_NUMBER: _ClassVar[int]
+    MOMENTMINAXIS_FIELD_NUMBER: _ClassVar[int]
+    MOMENTMAXAXIS_FIELD_NUMBER: _ClassVar[int]
+    DISPLACEMENTX_FIELD_NUMBER: _ClassVar[int]
+    DISPLACEMENTY_FIELD_NUMBER: _ClassVar[int]
+    DISPLACEMENTZ_FIELD_NUMBER: _ClassVar[int]
+    TOTALDISPLACEMENT_FIELD_NUMBER: _ClassVar[int]
+    axisForce: float
+    shearForceMinAxis: float
+    shearForceMaxAxis: float
+    momentMinAxis: float
+    momentMaxAxis: float
+    displacementX: float
+    displacementY: float
+    displacementZ: float
+    totalDisplacement: float
+    def __init__(self, axisForce: _Optional[float] = ..., shearForceMinAxis: _Optional[float] = ..., shearForceMaxAxis: _Optional[float] = ..., momentMinAxis: _Optional[float] = ..., momentMaxAxis: _Optional[float] = ..., displacementX: _Optional[float] = ..., displacementY: _Optional[float] = ..., displacementZ: _Optional[float] = ..., totalDisplacement: _Optional[float] = ...) -> None: ...
+
+class InterfaceNodalValues(_message.Message):
+    __slots__ = ("shearForce", "normalForceMinAxis", "normalForceMaxAxis", "confiningStress", "rockDisplacementX", "rockDisplacementY", "rockDisplacementZ", "rockTotalDisplacement")
+    SHEARFORCE_FIELD_NUMBER: _ClassVar[int]
+    NORMALFORCEMINAXIS_FIELD_NUMBER: _ClassVar[int]
+    NORMALFORCEMAXAXIS_FIELD_NUMBER: _ClassVar[int]
+    CONFININGSTRESS_FIELD_NUMBER: _ClassVar[int]
+    ROCKDISPLACEMENTX_FIELD_NUMBER: _ClassVar[int]
+    ROCKDISPLACEMENTY_FIELD_NUMBER: _ClassVar[int]
+    ROCKDISPLACEMENTZ_FIELD_NUMBER: _ClassVar[int]
+    ROCKTOTALDISPLACEMENT_FIELD_NUMBER: _ClassVar[int]
+    shearForce: float
+    normalForceMinAxis: float
+    normalForceMaxAxis: float
+    confiningStress: float
+    rockDisplacementX: float
+    rockDisplacementY: float
+    rockDisplacementZ: float
+    rockTotalDisplacement: float
+    def __init__(self, shearForce: _Optional[float] = ..., normalForceMinAxis: _Optional[float] = ..., normalForceMaxAxis: _Optional[float] = ..., confiningStress: _Optional[float] = ..., rockDisplacementX: _Optional[float] = ..., rockDisplacementY: _Optional[float] = ..., rockDisplacementZ: _Optional[float] = ..., rockTotalDisplacement: _Optional[float] = ...) -> None: ...

rs3/generatedFiles/BFPCommonMessage_pb2_grpc.py

@@ -0,0 +1,24 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+
+GRPC_GENERATED_VERSION = '1.70.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in BFPCommonMessage_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )

rs3/generatedFiles/BeamDataService_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: BeamDataService.proto
+# Protobuf Python Version: 5.29.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'BeamDataService.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+import CommonMessages_pb2 as CommonMessages__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x42\x65\x61mDataService.proto\x12\x19\x42\x65\x61mDataServiceDefinition\x1a\x14\x43ommonMessages.proto2\xef\x02\n\x0f\x42\x65\x61mDataService\x12V\n\x0bSetProperty\x12\".CommonMessages.SetPropertyRequest\x1a#.CommonMessages.SetPropertyResponse\x12V\n\x0bGetProperty\x12\".CommonMessages.GetPropertyRequest\x1a#.CommonMessages.GetPropertyResponse\x12U\n\x10SetColorProperty\x12\x1f.CommonMessages.SetColorRequest\x1a .CommonMessages.SetColorResponse\x12U\n\x10GetColorProperty\x12\x1f.CommonMessages.GetColorRequest\x1a .CommonMessages.GetColorResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'BeamDataService_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_BEAMDATASERVICE']._serialized_start=75
+  _globals['_BEAMDATASERVICE']._serialized_end=442
+# @@protoc_insertion_point(module_scope)

rs3/generatedFiles/BeamDataService_pb2.pyi

@@ -0,0 +1,5 @@
+import CommonMessages_pb2 as _CommonMessages_pb2
+from google.protobuf import descriptor as _descriptor
+from typing import ClassVar as _ClassVar
+
+DESCRIPTOR: _descriptor.FileDescriptor