RSSeismicScripting 3.0.0__py3-none-any.whl

rsseismic/Model.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rsseismic._client import Client
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import require_success
+from rsseismic.exceptions import ScriptingError
+from rsseismic.generatedFiles import ModelService_pb2 as ModelService_pb2
+from rsseismic.generatedFiles import ModelService_pb2_grpc as ModelService_pb2_grpc
+from rsseismic.MeanProfile import MeanProfile
+from rsseismic.Motions import Motions
+from rsseismic.ProfileGenerationSettings import ProfileGenerationSettings
+from rsseismic.Profiles import Profiles
+from rsseismic.ProjectSettings import ProjectSettings
+from rsseismic.Results import Results
+from rsseismic.SoilLayerOperations import SoilLayerOperations
+
+
+@dataclass(frozen=True)
+class RunComputeResult:
+    """Outcome of ``Model.runCompute()``."""
+
+    success: bool
+    partialSuccess: bool
+    errorMessage: str
+
+    @property
+    def ok(self) -> bool:
+        """True when every selected profile and motion pair completed successfully."""
+        return self.success and not self.partialSuccess
+
+
+@dataclass(frozen=True)
+class GenerateProfilesResult:
+    """Outcome of ``Model.generateProfiles()``."""
+
+    success: bool
+    errorMessage: str
+    validationErrors: list[str]
+    profileCount: int
+    profileNames: list[str]
+    hasBeenGenerated: bool
+
+    @property
+    def ok(self) -> bool:
+        """True when profile generation completed successfully."""
+        return self.success
+
+
+@dataclass(frozen=True)
+class ResetGeneratedProfilesResult:
+    """Outcome of ``Model.resetGeneratedProfiles()``."""
+
+    success: bool
+    errorMessage: str
+    hasBeenGenerated: bool
+
+
+class Model(_ProxyObject):
+    """
+    Handle for an open RSSeismic project.
+
+    Obtain a ``Model`` from ``RSSeismicApplication.openFile(path)`` or
+    ``RSSeismicApplication.newProject()``.
+
+    Use the attributes on this object to work with project data: ``Profiles``,
+    ``Motions``, ``Results``, ``MeanProfile``, ``ProjectSettings``,
+    ``ProfileGenerationSettings``, and ``SoilLayers``.
+    """
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self._model_service = ModelService_pb2_grpc.ModelServiceStub(self._client.channel)
+        self.Motions = Motions(client, modelId)
+        self.Profiles = Profiles(client, modelId)
+        self.ProjectSettings = ProjectSettings(client, modelId)
+        self.ProfileGenerationSettings = ProfileGenerationSettings(client, modelId)
+        self.MeanProfile = MeanProfile(client, modelId)
+        self.SoilLayers = SoilLayerOperations(client, modelId)
+        self.Results = Results(client, modelId)
+
+    @property
+    def modelId(self) -> str:
+        return self._objectId
+
+    def save(self) -> None:
+        """Save the project to its current file path."""
+        request = ModelService_pb2.SaveRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._model_service.Save, request)
+        require_success(response, "Save")
+
+    def saveAs(self, filePath: str) -> None:
+        """Save the project to a new file path."""
+        request = ModelService_pb2.SaveAsRequest(modelID=self._objectId, filePath=filePath)
+        response = self._client.callFunction(self._model_service.SaveAs, request)
+        require_success(response, "SaveAs")
+
+    def close(self, saveProject: bool = False) -> None:
+        """
+        Close the project in RSSeismic.
+
+        When ``saveProject`` is True, the project is saved before it is closed.
+        """
+        request = ModelService_pb2.CloseRequest(
+            modelID=self._objectId,
+            saveProject=saveProject,
+        )
+        response = self._client.callFunction(self._model_service.Close, request)
+        require_success(response, "Close")
+
+    def runCompute(self, timeout: float | None = None) -> RunComputeResult:
+        """
+        Run analysis for all selected profile and motion combinations.
+
+        Returns a ``RunComputeResult``. Check ``result.ok`` for full success.
+        When ``partialSuccess`` is True, some pairs completed but others failed;
+        see ``errorMessage`` for details.
+
+        Optional ``timeout`` is the maximum wait time in seconds for long runs.
+        When omitted, the call waits until compute finishes.
+        """
+        request = ModelService_pb2.RunComputeRequest(modelID=self._objectId)
+        response = self._client.callFunction(
+            self._model_service.RunCompute,
+            request,
+            timeout=timeout,
+        )
+        return RunComputeResult(
+            success=response.success,
+            partialSuccess=response.partialSuccess,
+            errorMessage=response.errorMessage or "",
+        )
+
+    def clearResults(self) -> None:
+        """Remove stored analysis results from the project."""
+        request = ModelService_pb2.ClearResultsRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._model_service.ClearResults, request)
+        require_success(response, "ClearResults")
+
+    def resetGeneratedProfiles(self) -> ResetGeneratedProfilesResult:
+        """
+        Clear the generated-profiles state so profiles can be generated again.
+
+        Does not remove profiles already in the project. Requires automatic profile
+        generation to be enabled in project settings.
+        """
+        request = ModelService_pb2.ResetGeneratedProfilesRequest(modelID=self._objectId)
+        response = self._client.callFunction(
+            self._model_service.ResetGeneratedProfiles,
+            request,
+        )
+        require_success(response, "ResetGeneratedProfiles")
+        return ResetGeneratedProfilesResult(
+            success=response.success,
+            errorMessage=response.errorMessage or "",
+            hasBeenGenerated=response.hasBeenGenerated,
+        )
+
+    def generateProfiles(
+        self,
+        seed: int = 0,
+        timeout: float | None = None,
+    ) -> GenerateProfilesResult:
+        """
+        Create individual profiles from the mean profile template.
+
+        Validates ``model.MeanProfile`` first, then replaces the profiles in the
+        project with the newly generated set. Configure how many profiles to create
+        with ``model.ProfileGenerationSettings`` before calling this method.
+
+        When ``seed`` is 0, RSSeismic chooses a random seed. Use a fixed seed to
+        reproduce the same generated profiles.
+
+        Optional ``timeout`` is the maximum wait time in seconds. When omitted, the
+        call waits until generation finishes.
+
+        Raises:
+            ScriptingError: Validation failed or generation could not complete.
+        """
+        request = ModelService_pb2.GenerateProfilesRequest(
+            modelID=self._objectId,
+            seed=seed,
+        )
+        response = self._client.callFunction(
+            self._model_service.GenerateProfiles,
+            request,
+            timeout=timeout,
+        )
+        if not response.success:
+            message = response.errorMessage or "GenerateProfiles failed."
+            if response.validationErrors:
+                details = "\n".join(f"- {error}" for error in response.validationErrors)
+                message = f"{message}\n{details}"
+            raise ScriptingError(message)
+
+        return GenerateProfilesResult(
+            success=response.success,
+            errorMessage=response.errorMessage or "",
+            validationErrors=list(response.validationErrors),
+            profileCount=response.profileCount,
+            profileNames=list(response.profileNames),
+            hasBeenGenerated=response.hasBeenGenerated,
+        )

rsseismic/Motions.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from rsseismic._client import Client
+from rsseismic._proto_converters import from_motion_entry, from_motion_pair_entry
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import log_success_advisory, require_success
+from rsseismic.generatedFiles import MotionService_pb2 as MotionService_pb2
+from rsseismic.generatedFiles import MotionService_pb2_grpc as MotionService_pb2_grpc
+from rsseismic.types import MotionInfo, MotionPairInfo
+
+
+class Motions(_ProxyObject):
+    """Ground motion directories, scanning, listing, and selection for an open model."""
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self._motion_service = MotionService_pb2_grpc.MotionServiceStub(self._client.channel)
+
+    def listMotionDirectories(self) -> list[str]:
+        """Return motion directories currently associated with this project."""
+        request = MotionService_pb2.ListMotionDirectoriesRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._motion_service.ListMotionDirectories, request)
+        require_success(response, "ListMotionDirectories")
+        return list(response.directories)
+
+    def addMotionDirectory(self, motionDirectory: str) -> list[str]:
+        """
+        Add a folder to app motion-directory preferences (global, not project-specific).
+
+        Returns the updated list of preference directories. If the directory is already
+        listed, the server returns success with a warning.
+        """
+        request = MotionService_pb2.AddMotionDirectoryRequest(motionDirectory=motionDirectory)
+        response = self._client.callFunction(self._motion_service.AddMotionDirectory, request)
+        require_success(response, "AddMotionDirectory")
+        log_success_advisory(response)
+        return list(response.directories)
+
+    def removeMotionDirectory(self, motionDirectory: str) -> list[str]:
+        """
+        Remove a folder from app motion-directory preferences.
+
+        At least one directory must remain. Returns the updated preference list.
+        """
+        request = MotionService_pb2.RemoveMotionDirectoryRequest(motionDirectory=motionDirectory)
+        response = self._client.callFunction(self._motion_service.RemoveMotionDirectory, request)
+        require_success(response, "RemoveMotionDirectory")
+        return list(response.directories)
+
+    def refreshMotionsList(self) -> int:
+        """
+        Copy preference directories onto the project and rescan motion files.
+
+        Returns the number of motions loaded.
+        """
+        request = MotionService_pb2.RefreshMotionsListRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._motion_service.RefreshMotionsList, request)
+        require_success(response, "RefreshMotionsList")
+        return response.motionsLoaded
+
+    def listMotions(self) -> list[MotionInfo]:
+        """Return all motions with name, file path, and selection state (uni-directional projects only)."""
+        request = MotionService_pb2.ListMotionsRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._motion_service.ListMotions, request)
+        require_success(response, "ListMotions")
+        return [from_motion_entry(motion) for motion in response.motions]
+
+    def setMotionSelection(
+        self,
+        motionNames: list[str],
+        selectOnlyListed: bool = True,
+    ) -> None:
+        """
+        Select motions by name (uni-directional projects only).
+
+        When selectOnlyListed is True (default), only the listed motions remain selected.
+        """
+        request = MotionService_pb2.SetMotionSelectionRequest(
+            modelID=self._objectId,
+            motionNames=motionNames,
+            selectOnlyListed=selectOnlyListed,
+        )
+        response = self._client.callFunction(self._motion_service.SetMotionSelection, request)
+        require_success(response, "SetMotionSelection")
+
+    def listMotionPairs(self) -> list[MotionPairInfo]:
+        """Return horizontal motion pairs inferred from file names (bi-directional projects only)."""
+        request = MotionService_pb2.ListMotionPairsRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._motion_service.ListMotionPairs, request)
+        require_success(response, "ListMotionPairs")
+        return [from_motion_pair_entry(pair) for pair in response.pairs]
+
+    def setMotionPairSelection(
+        self,
+        pairIds: list[str],
+        selectOnlyListed: bool = True,
+    ) -> None:
+        """
+        Select motion pairs by pair id (bi-directional projects only).
+
+        When selectOnlyListed is True (default), only the listed pairs remain selected.
+        Selecting a pair selects both horizontal components.
+        """
+        request = MotionService_pb2.SetMotionPairSelectionRequest(
+            modelID=self._objectId,
+            pairIds=pairIds,
+            selectOnlyListed=selectOnlyListed,
+        )
+        response = self._client.callFunction(self._motion_service.SetMotionPairSelection, request)
+        require_success(response, "SetMotionPairSelection")
+
+    def selectAllMotions(self) -> None:
+        """Select all motions (uni-directional) or all motion pairs (bi-directional)."""
+        request = MotionService_pb2.SelectAllMotionsRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._motion_service.SelectAllMotions, request)
+        require_success(response, "SelectAllMotions")
+
+    def deselectAllMotions(self) -> None:
+        """Deselect all motions (uni-directional) or all motion pairs (bi-directional)."""
+        request = MotionService_pb2.DeselectAllMotionsRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._motion_service.DeselectAllMotions, request)
+        require_success(response, "DeselectAllMotions")
+
+    def selectAllMotionsInDirectory(self, motionDirectory: str) -> None:
+        """Select all motions or pairs (by H1 folder) whose files are in the given directory."""
+        request = MotionService_pb2.SelectAllMotionsInDirectoryRequest(
+            modelID=self._objectId,
+            motionDirectory=motionDirectory,
+        )
+        response = self._client.callFunction(self._motion_service.SelectAllMotionsInDirectory, request)
+        require_success(response, "SelectAllMotionsInDirectory")
+
+    def deselectAllMotionsInDirectory(self, motionDirectory: str) -> None:
+        """Deselect all motions or pairs (by H1 folder) whose files are in the given directory."""
+        request = MotionService_pb2.DeselectAllMotionsInDirectoryRequest(
+            modelID=self._objectId,
+            motionDirectory=motionDirectory,
+        )
+        response = self._client.callFunction(self._motion_service.DeselectAllMotionsInDirectory, request)
+        require_success(response, "DeselectAllMotionsInDirectory")

rsseismic/ProfileGenerationSettings.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from rsseismic._client import Client
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic.generatedFiles import ProfileGenerationSettingsService_pb2_grpc as ProfileGenerationSettingsService_pb2_grpc
+from rsseismic.properties._PropertyAccessor import PropertyAccessor
+from rsseismic.properties.profileGenerationSettings._generated import ProfileGenerationSettingsPropertiesMixin
+
+
+class ProfileGenerationSettings(_ProxyObject, ProfileGenerationSettingsPropertiesMixin):
+    """
+    Settings that control automatic profile generation.
+
+    Access via ``model.ProfileGenerationSettings``. Use the generated ``get*`` /
+    ``set*`` helpers to configure how many profiles to create, randomization options,
+    and related parameters (for example ``setProfilesToGenerate``).
+
+    After profiles have been generated once, call ``model.resetGeneratedProfiles()``
+    before generating again. Use ``model.generateProfiles()`` to create profiles from
+    the mean profile template.
+    """
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self.modelId = modelId
+        self._settings_service = ProfileGenerationSettingsService_pb2_grpc.ProfileGenerationSettingsServiceStub(
+            self._client.channel
+        )
+        self.Data = PropertyAccessor(client, modelId, self._settings_service)

rsseismic/Profiles.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rsseismic._client import Client
+from rsseismic._proto_converters import (
+    from_active_profile_response,
+    from_bedrock_layer_entry,
+    from_profile_entry,
+    from_soil_layer_entry,
+)
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import require_success
+from rsseismic.generatedFiles import ProfileService_pb2 as ProfileService_pb2
+from rsseismic.generatedFiles import ProfileService_pb2_grpc as ProfileService_pb2_grpc
+from rsseismic.types import (
+    ActiveProfile,
+    BedrockLayerSummary,
+    DeleteProfileResult,
+    ProfileSummary,
+    SoilLayerSummary,
+)
+
+if TYPE_CHECKING:
+    from rsseismic.BedrockLayer import BedrockLayer
+    from rsseismic.SoilLayer import SoilLayer
+
+
+class Profiles(_ProxyObject):
+    """Profile navigation and CRUD for an open model."""
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self._profile_service = ProfileService_pb2_grpc.ProfileServiceStub(self._client.channel)
+
+    def listProfiles(self) -> list[ProfileSummary]:
+        request = ProfileService_pb2.ListProfilesRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._profile_service.ListProfiles, request)
+        require_success(response, "ListProfiles")
+        return [from_profile_entry(profile) for profile in response.profiles]
+
+    def getActiveProfile(self) -> ActiveProfile:
+        request = ProfileService_pb2.GetActiveProfileRequest(modelID=self._objectId)
+        response = self._client.callFunction(self._profile_service.GetActiveProfile, request)
+        require_success(response, "GetActiveProfile")
+        return from_active_profile_response(response)
+
+    def setActiveProfile(self, profileName: str) -> None:
+        request = ProfileService_pb2.SetActiveProfileRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.SetActiveProfile, request)
+        require_success(response, "SetActiveProfile")
+
+    def listSoilLayers(self, profileName: str = "") -> list[SoilLayerSummary]:
+        """
+        List soil layers for a profile.
+
+        When profileName is empty, the active profile is used.
+        """
+        request = ProfileService_pb2.ListSoilLayersRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.ListSoilLayers, request)
+        require_success(response, "ListSoilLayers")
+        return [from_soil_layer_entry(layer) for layer in response.layers]
+
+    def listActiveSoilLayers(self) -> list[SoilLayerSummary]:
+        """List soil layers for the active profile."""
+        return self.listSoilLayers("")
+
+    def getBedrockLayer(self, profileName: str = "") -> BedrockLayerSummary:
+        """
+        Return the bedrock layer for a profile.
+
+        When profileName is empty, the active profile is used.
+        """
+        request = ProfileService_pb2.GetBedrockLayerRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.GetBedrockLayer, request)
+        require_success(response, "GetBedrockLayer")
+        return from_bedrock_layer_entry(response.bedrock)
+
+    def getActiveBedrockLayer(self) -> BedrockLayerSummary:
+        """Return the bedrock layer for the active profile."""
+        return self.getBedrockLayer("")
+
+    def getSoilLayer(self, layerId: str) -> SoilLayer:
+        """Return a property proxy for a soil layer GUID."""
+        from rsseismic.SoilLayer import SoilLayer
+
+        return SoilLayer(self._client, self._objectId, layerId)
+
+    def getBedrockLayerProxy(self, profileName: str = "") -> BedrockLayer:
+        """Return a property proxy for the bedrock layer of a profile."""
+        from rsseismic.BedrockLayer import BedrockLayer
+
+        entry = self.getBedrockLayer(profileName)
+        return BedrockLayer(self._client, self._objectId, entry.layerID)
+
+    def createProfile(self, profileName: str = "") -> str:
+        """
+        Create a new profile and make it active.
+
+        When profileName is empty, the server assigns a unique default name.
+        """
+        request = ProfileService_pb2.CreateProfileRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.CreateProfile, request)
+        require_success(response, "CreateProfile")
+        return response.profileName
+
+    def copyProfile(self, profileName: str = "") -> str:
+        """
+        Copy the active profile and make the copy active.
+
+        When profileName is empty, the server assigns a unique default name.
+        """
+        request = ProfileService_pb2.CopyProfileRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.CopyProfile, request)
+        require_success(response, "CopyProfile")
+        return response.profileName
+
+    def deleteProfile(self, profileName: str) -> DeleteProfileResult:
+        """Delete a profile by name. At least one profile must remain."""
+        request = ProfileService_pb2.DeleteProfileRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.DeleteProfile, request)
+        require_success(response, "DeleteProfile")
+        return DeleteProfileResult(
+            deletedProfileName=response.deletedProfileName,
+            activeProfileName=response.activeProfileName,
+        )
+
+    def renameActiveProfile(self, newProfileName: str) -> str:
+        """Rename the active profile."""
+        request = ProfileService_pb2.RenameActiveProfileRequest(
+            modelID=self._objectId,
+            newProfileName=newProfileName,
+        )
+        response = self._client.callFunction(self._profile_service.RenameActiveProfile, request)
+        require_success(response, "RenameActiveProfile")
+        return response.profileName
+
+    def getOutputDepths(self, profileName: str = "") -> list[float]:
+        """
+        Return output depths for a profile in project length units.
+
+        When profileName is empty, the active profile is used.
+        """
+        request = ProfileService_pb2.GetOutputDepthsRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+        )
+        response = self._client.callFunction(self._profile_service.GetOutputDepths, request)
+        require_success(response, "GetOutputDepths")
+        return list(response.depths)
+
+    def getActiveOutputDepths(self) -> list[float]:
+        """Return output depths for the active profile."""
+        return self.getOutputDepths("")
+
+    def setOutputDepths(self, depths: list[float], profileName: str = "") -> None:
+        """
+        Set output depths for a profile in project length units.
+
+        When profileName is empty, the active profile is used.
+        """
+        request = ProfileService_pb2.SetOutputDepthsRequest(
+            modelID=self._objectId,
+            profileName=profileName,
+            depths=depths,
+        )
+        response = self._client.callFunction(self._profile_service.SetOutputDepths, request)
+        require_success(response, "SetOutputDepths")

rsseismic/ProjectSettings.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from rsseismic._client import Client
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import require_success
+from rsseismic.generatedFiles import ProjectSettingsDataService_pb2 as ProjectSettingsDataService_pb2
+from rsseismic.generatedFiles import ProjectSettingsDataService_pb2_grpc as ProjectSettingsDataService_pb2_grpc
+from rsseismic.properties._PropertyAccessor import PropertyAccessor
+from rsseismic.types import UnitSystem
+from rsseismic.properties.projectSettings._generated import ProjectSettingsPropertiesMixin
+
+
+class ProjectSettings(_ProxyObject, ProjectSettingsPropertiesMixin):
+    """
+    Project-wide settings for analysis, motions, and output.
+
+    Access via ``model.ProjectSettings``. Use the generated ``get*`` / ``set*`` helpers
+    for options such as analysis method, input motion configuration, default soil model,
+    and automatic profile generation. Use ``getUnitSystem()`` and ``changeUnitSystem()``
+    to read or switch between metric and imperial units.
+    """
+
+    def __init__(self, client: Client, modelId: str):
+        super().__init__(client, modelId)
+        self.modelId = modelId
+        self._settings_service = ProjectSettingsDataService_pb2_grpc.ProjectSettingsDataServiceStub(
+            self._client.channel
+        )
+        self.Data = PropertyAccessor(client, modelId, self._settings_service)
+
+    def getUnitSystem(self) -> UnitSystem:
+        """Return the project unit system (Metric or Imperial)."""
+        request = ProjectSettingsDataService_pb2.GetUnitSystemRequest(objectId=self._objectId)
+        response = self._client.callFunction(self._settings_service.GetUnitSystem, request)
+        require_success(response, "GetUnitSystem")
+        return UnitSystem.from_is_metric(response.isMetric)
+
+    def changeUnitSystem(self, unitSystem: UnitSystem) -> UnitSystem:
+        """Switch between metric and imperial units. Returns the unit system now in effect."""
+        request = ProjectSettingsDataService_pb2.ChangeUnitSystemRequest(
+            objectId=self._objectId,
+            useMetric=unitSystem.to_use_metric(),
+        )
+        response = self._client.callFunction(self._settings_service.ChangeUnitSystem, request)
+        require_success(response, "ChangeUnitSystem")
+        return UnitSystem.from_is_metric(response.isMetric)

rsseismic/ReferenceCurve.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from rsseismic._client import Client
+from rsseismic._proto_converters import from_reference_curve_points, to_reference_curve_points
+from rsseismic._proxyObject import _ProxyObject
+from rsseismic._rpc_helpers import log_success_advisory, require_success
+from rsseismic.types import DynamicsPoint
+from rsseismic.generatedFiles import ReferenceCurveDataService_pb2 as ReferenceCurveDataService_pb2
+from rsseismic.generatedFiles import ReferenceCurveDataService_pb2_grpc as ReferenceCurveDataService_pb2_grpc
+from rsseismic.properties._PropertyAccessor import ProjectScopedPropertyAccessor
+from rsseismic.properties.referenceCurve._generated import ReferenceCurvePropertiesMixin
+
+
+class ReferenceCurve(_ProxyObject, ReferenceCurvePropertiesMixin):
+    """
+    Reference curve for a soil layer.
+
+    Access via ``layer.ReferenceCurve`` on a ``SoilLayer`` or ``MeanProfileSoilLayer``.
+    Use the generated ``get*`` / ``set*`` helpers to configure the curve model, soil type,
+    and related parameters. Use ``getCurvePoints`` / ``setCurvePoints`` for user-defined
+    curves, or call ``generateReferenceCurve()`` to build the curve from those settings.
+
+    On mean-profile template layers, ``generateReferenceCurve()`` is not available;
+    set properties and points directly instead.
+    """
+
+    def __init__(self, client: Client, modelId: str, layerId: str):
+        super().__init__(client, layerId)
+        self.modelId = modelId
+        stub = ReferenceCurveDataService_pb2_grpc.ReferenceCurveDataServiceStub(self._client.channel)
+        self.Data = ProjectScopedPropertyAccessor(client, modelId, layerId, stub)
+        self._service = stub
+
+    @property
+    def layerId(self) -> str:
+        return self._objectId
+
+    def getCurvePoints(self) -> list[DynamicsPoint]:
+        """Return reference curve points."""
+        request = ReferenceCurveDataService_pb2.GetReferenceCurvePointsRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+        )
+        response = self._client.callFunction(self._service.GetCurvePoints, request)
+        require_success(response, "GetCurvePoints")
+        return from_reference_curve_points(list(response.points))
+
+    def setCurvePoints(self, points: list[DynamicsPoint]) -> None:
+        """Set reference curve points when using a user-defined curve model."""
+        if not points:
+            raise ValueError("At least one curve point is required.")
+        request = ReferenceCurveDataService_pb2.SetReferenceCurvePointsRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+            points=to_reference_curve_points(points),
+        )
+        response = self._client.callFunction(self._service.SetCurvePoints, request)
+        require_success(response, "SetCurvePoints")
+
+    def generateReferenceCurve(self) -> int:
+        """
+        Build the reference curve from the current curve model, soil type, and parameters.
+
+        Returns the number of points created. Not available on mean-profile template layers.
+        """
+        request = ReferenceCurveDataService_pb2.GenerateReferenceCurveRequest(
+            projectId=self.modelId,
+            layerID=self._objectId,
+        )
+        response = self._client.callFunction(self._service.GenerateReferenceCurve, request)
+        require_success(response, "GenerateReferenceCurve")
+        log_success_advisory(response)
+        return response.pointCount