RSSeismicScripting 3.0.0__tar.gz

rsseismicscripting-3.0.0/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2026 Rocscience Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

rsseismicscripting-3.0.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: RSSeismicScripting
+Version: 3.0.0
+Summary: Client library for interacting with RSSeismic (DeepSoil) through Python
+Author: Rocscience
+License-Expression: MIT
+Project-URL: Homepage, https://www.rocscience.com/software/rsseismic
+Project-URL: Documentation, https://rocscience.github.io/rsseismic-scripting/
+Keywords: Rocscience,RSSeismic,DeepSoil,Scripting,RocScript,Geotechnical,Seismic
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: License.txt
+Requires-Dist: grpcio>=1.64.1
+Requires-Dist: protobuf<6.0
+Requires-Dist: pandas>=2.0
+Requires-Dist: matplotlib>=3.7
+Dynamic: license-file
+
+## Introduction
+
+This repo contains the reference manual for the RSSeismic scripting library. The RSSeismic scripting library is used to interact with the RSSeismic application through Python.
+
+| Resource | Link |
+|----------|------|
+| **Reference manual (this site)** | https://rocscience.github.io/rsseismic-scripting/ |
+| **PyPI package** | https://pypi.org/project/RSSeismicScripting/ |
+| **RSSeismic release notes** | https://www.rocscience.com/support/rsseismic/release-notes |
+| **Program downloads** | https://www.rocscience.com/support/program-downloads |
+
+### Goal
+
+Each function exposed corresponds to an equivalent operation you could have done through the UI.
+Using this idea, the user should be able to edit models and get results without having to go through the UI at all.
+Although only a limited set of functionality is exposed for now, the library covers the main scripting workflows. For a list of what is exposed in the current library, see [Exposed Functionality](#exposed-functionality).
+
+### Python UI equivalents
+
+Events and workflows done in the UI will have equivalents in the Python library.
+Wherever a dialog is shown in the UI, there will be an equivalent class with methods that mimic the dialog's behavior.
+Wherever a warning or error dialog is displayed, an exception will be thrown, or a warning will be displayed in Python instead.
+Wherever you can select and manipulate an entity, identifiers can be used in the library to get references to those entities in Python and objects will be constructed to help you interface with them.
+
+### How it works
+
+Each function in the library is a wrapper to make an API call to the application.
+Objects retrieved through function calls will often not contain any data themselves, but will instead be proxies, allowing you to get information from the objects in the application.
+For this reason, debugging will sometimes be tricky, as not all data will always be available for you to inspect unless you get it and assign it to a variable yourself.
+
+### Warnings
+
+References can be *invalidated* whenever the corresponding object in the application is destroyed or reloaded. You will need to watch out for expired references and renew them when needed as it can cause crashes or incorrect results if not managed properly.
+
+## Exposed Functionality
+
+The library exposes a focused set of RSSeismic workflows through Python. In this version you can:
+
+- **Application connection**: Launch RSSeismic with the scripting server (`startApplication`), connect on a port, `ping`, open `.rsseismicfile` projects, create blank projects, adjust `maxConcurrentAnalyses`, run **batch compute** across many project files, and close the client connection.
+
+- **Project lifecycle (`Model`)**: Save, save as, close, **run compute** (with optional timeout and partial-success handling), clear results, and automatic profile **generate** / **reset** when that feature is enabled on the project.
+
+- **Profiles (`model.Profiles`)**: List, create, copy, delete, and rename profiles; active profile; list soil layers and bedrock; output depths; get **SoilLayer** / **BedrockLayer** property proxies.
+
+- **Profile layer CRUD (`model.SoilLayers`)**: Insert, append, delete, duplicate, and move soil layers on the active profile.
+
+- **Mean profile (`model.MeanProfile`)**: Structure CRUD on the automatic-generation template; **MeanProfileSoilLayer** properties including vary-with-depth shear wave / shear strength tables and **ReferenceCurve** (without auto-generate on template layers).
+
+- **Profile generation settings (`model.ProfileGenerationSettings`)**: Typed getters/setters for randomization, profile count, and related generation parameters.
+
+- **Project settings (`model.ProjectSettings`)**: Typed project properties (analysis mode, solver, motions configuration, automatic profile generation, etc.), plus **unit system** get/change.
+
+- **Ground motions (`model.Motions`)**: Motion directory preferences (add/remove/list), refresh project motion list, **uni-directional** motion list/selection or **bi-directional** pair list/selection, select-all and per-directory select/deselect.
+
+- **Layer properties**: **SoilLayer** (thickness, soil model, unit weight, …), **ReferenceCurve** (curve model, points, generate reference curve on profile layers), **SoilLayerCurve** (dynamics, discrete points, **curve fit** via `FittingProcedureModel`), **BedrockLayer** on realized profiles.
+
+- **Results (`model.Results`)**: Result paths and database metadata; compute-aligned motion/layer discovery; **pandas DataFrames** for profile/layer time histories, profile summaries, result series (`ResultSeriesKind`), strain convergence, and real-time displacement; bulk fetch helpers for many motions/layers.
+
+- **Public types and enums**: Summary dataclasses (`ProfileSummary`, `MotionInfo`, `ResultDatabaseInfo`, …), `ResultSeriesKind`, `ResultMotionType`, `UnitSystem`, and property enums under `rsseismic.enums` (for example `SoilModel`, `AnalysisMode`, `InputMotionConfiguration`, `FittingProcedureModel`).
+
+RPC failures raise **`ScriptingError`**. Some successful RPCs carry advisory text in `errorMessage`; the client logs those as **warnings** (for example duplicate motion directory add).
+
+For method-level detail, use the [Scripting reference manual](https://rocscience.github.io/rsseismic-scripting/) (API reference and example scripts).
+
+## Getting Started
+
+- **Tutorials and workflows (Rocscience Help):** https://www.rocscience.com/help/rsseismic/tutorials/
+- **Product documentation:** https://www.rocscience.com/help/rsseismic/documentation/

rsseismicscripting-3.0.0/README.md

@@ -0,0 +1,68 @@
+## Introduction
+
+This repo contains the reference manual for the RSSeismic scripting library. The RSSeismic scripting library is used to interact with the RSSeismic application through Python.
+
+| Resource | Link |
+|----------|------|
+| **Reference manual (this site)** | https://rocscience.github.io/rsseismic-scripting/ |
+| **PyPI package** | https://pypi.org/project/RSSeismicScripting/ |
+| **RSSeismic release notes** | https://www.rocscience.com/support/rsseismic/release-notes |
+| **Program downloads** | https://www.rocscience.com/support/program-downloads |
+
+### Goal
+
+Each function exposed corresponds to an equivalent operation you could have done through the UI.
+Using this idea, the user should be able to edit models and get results without having to go through the UI at all.
+Although only a limited set of functionality is exposed for now, the library covers the main scripting workflows. For a list of what is exposed in the current library, see [Exposed Functionality](#exposed-functionality).
+
+### Python UI equivalents
+
+Events and workflows done in the UI will have equivalents in the Python library.
+Wherever a dialog is shown in the UI, there will be an equivalent class with methods that mimic the dialog's behavior.
+Wherever a warning or error dialog is displayed, an exception will be thrown, or a warning will be displayed in Python instead.
+Wherever you can select and manipulate an entity, identifiers can be used in the library to get references to those entities in Python and objects will be constructed to help you interface with them.
+
+### How it works
+
+Each function in the library is a wrapper to make an API call to the application.
+Objects retrieved through function calls will often not contain any data themselves, but will instead be proxies, allowing you to get information from the objects in the application.
+For this reason, debugging will sometimes be tricky, as not all data will always be available for you to inspect unless you get it and assign it to a variable yourself.
+
+### Warnings
+
+References can be *invalidated* whenever the corresponding object in the application is destroyed or reloaded. You will need to watch out for expired references and renew them when needed as it can cause crashes or incorrect results if not managed properly.
+
+## Exposed Functionality
+
+The library exposes a focused set of RSSeismic workflows through Python. In this version you can:
+
+- **Application connection**: Launch RSSeismic with the scripting server (`startApplication`), connect on a port, `ping`, open `.rsseismicfile` projects, create blank projects, adjust `maxConcurrentAnalyses`, run **batch compute** across many project files, and close the client connection.
+
+- **Project lifecycle (`Model`)**: Save, save as, close, **run compute** (with optional timeout and partial-success handling), clear results, and automatic profile **generate** / **reset** when that feature is enabled on the project.
+
+- **Profiles (`model.Profiles`)**: List, create, copy, delete, and rename profiles; active profile; list soil layers and bedrock; output depths; get **SoilLayer** / **BedrockLayer** property proxies.
+
+- **Profile layer CRUD (`model.SoilLayers`)**: Insert, append, delete, duplicate, and move soil layers on the active profile.
+
+- **Mean profile (`model.MeanProfile`)**: Structure CRUD on the automatic-generation template; **MeanProfileSoilLayer** properties including vary-with-depth shear wave / shear strength tables and **ReferenceCurve** (without auto-generate on template layers).
+
+- **Profile generation settings (`model.ProfileGenerationSettings`)**: Typed getters/setters for randomization, profile count, and related generation parameters.
+
+- **Project settings (`model.ProjectSettings`)**: Typed project properties (analysis mode, solver, motions configuration, automatic profile generation, etc.), plus **unit system** get/change.
+
+- **Ground motions (`model.Motions`)**: Motion directory preferences (add/remove/list), refresh project motion list, **uni-directional** motion list/selection or **bi-directional** pair list/selection, select-all and per-directory select/deselect.
+
+- **Layer properties**: **SoilLayer** (thickness, soil model, unit weight, …), **ReferenceCurve** (curve model, points, generate reference curve on profile layers), **SoilLayerCurve** (dynamics, discrete points, **curve fit** via `FittingProcedureModel`), **BedrockLayer** on realized profiles.
+
+- **Results (`model.Results`)**: Result paths and database metadata; compute-aligned motion/layer discovery; **pandas DataFrames** for profile/layer time histories, profile summaries, result series (`ResultSeriesKind`), strain convergence, and real-time displacement; bulk fetch helpers for many motions/layers.
+
+- **Public types and enums**: Summary dataclasses (`ProfileSummary`, `MotionInfo`, `ResultDatabaseInfo`, …), `ResultSeriesKind`, `ResultMotionType`, `UnitSystem`, and property enums under `rsseismic.enums` (for example `SoilModel`, `AnalysisMode`, `InputMotionConfiguration`, `FittingProcedureModel`).
+
+RPC failures raise **`ScriptingError`**. Some successful RPCs carry advisory text in `errorMessage`; the client logs those as **warnings** (for example duplicate motion directory add).
+
+For method-level detail, use the [Scripting reference manual](https://rocscience.github.io/rsseismic-scripting/) (API reference and example scripts).
+
+## Getting Started
+
+- **Tutorials and workflows (Rocscience Help):** https://www.rocscience.com/help/rsseismic/tutorials/
+- **Product documentation:** https://www.rocscience.com/help/rsseismic/documentation/

rsseismicscripting-3.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "RSSeismicScripting"
+version = "3.0.0"
+dependencies = [
+  "grpcio>=1.64.1",
+  "protobuf<6.0",
+  "pandas>=2.0",
+  "matplotlib>=3.7",
+]
+authors = [
+  { name = "Rocscience" },
+]
+description = "Client library for interacting with RSSeismic (DeepSoil) through Python"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering",
+]
+keywords = ["Rocscience", "RSSeismic", "DeepSoil", "Scripting", "RocScript", "Geotechnical", "Seismic"]
+
+license = "MIT"
+license-files = ["License.txt"]
+
+[project.urls]
+Homepage = "https://www.rocscience.com/software/rsseismic"
+Documentation = "https://rocscience.github.io/rsseismic-scripting/"
+
+[tool.setuptools.packages.find]
+where = ["src"]

rsseismicscripting-3.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rsseismicscripting-3.0.0/src/RSSeismicScripting.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: RSSeismicScripting
+Version: 3.0.0
+Summary: Client library for interacting with RSSeismic (DeepSoil) through Python
+Author: Rocscience
+License-Expression: MIT
+Project-URL: Homepage, https://www.rocscience.com/software/rsseismic
+Project-URL: Documentation, https://rocscience.github.io/rsseismic-scripting/
+Keywords: Rocscience,RSSeismic,DeepSoil,Scripting,RocScript,Geotechnical,Seismic
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: License.txt
+Requires-Dist: grpcio>=1.64.1
+Requires-Dist: protobuf<6.0
+Requires-Dist: pandas>=2.0
+Requires-Dist: matplotlib>=3.7
+Dynamic: license-file
+
+## Introduction
+
+This repo contains the reference manual for the RSSeismic scripting library. The RSSeismic scripting library is used to interact with the RSSeismic application through Python.
+
+| Resource | Link |
+|----------|------|
+| **Reference manual (this site)** | https://rocscience.github.io/rsseismic-scripting/ |
+| **PyPI package** | https://pypi.org/project/RSSeismicScripting/ |
+| **RSSeismic release notes** | https://www.rocscience.com/support/rsseismic/release-notes |
+| **Program downloads** | https://www.rocscience.com/support/program-downloads |
+
+### Goal
+
+Each function exposed corresponds to an equivalent operation you could have done through the UI.
+Using this idea, the user should be able to edit models and get results without having to go through the UI at all.
+Although only a limited set of functionality is exposed for now, the library covers the main scripting workflows. For a list of what is exposed in the current library, see [Exposed Functionality](#exposed-functionality).
+
+### Python UI equivalents
+
+Events and workflows done in the UI will have equivalents in the Python library.
+Wherever a dialog is shown in the UI, there will be an equivalent class with methods that mimic the dialog's behavior.
+Wherever a warning or error dialog is displayed, an exception will be thrown, or a warning will be displayed in Python instead.
+Wherever you can select and manipulate an entity, identifiers can be used in the library to get references to those entities in Python and objects will be constructed to help you interface with them.
+
+### How it works
+
+Each function in the library is a wrapper to make an API call to the application.
+Objects retrieved through function calls will often not contain any data themselves, but will instead be proxies, allowing you to get information from the objects in the application.
+For this reason, debugging will sometimes be tricky, as not all data will always be available for you to inspect unless you get it and assign it to a variable yourself.
+
+### Warnings
+
+References can be *invalidated* whenever the corresponding object in the application is destroyed or reloaded. You will need to watch out for expired references and renew them when needed as it can cause crashes or incorrect results if not managed properly.
+
+## Exposed Functionality
+
+The library exposes a focused set of RSSeismic workflows through Python. In this version you can:
+
+- **Application connection**: Launch RSSeismic with the scripting server (`startApplication`), connect on a port, `ping`, open `.rsseismicfile` projects, create blank projects, adjust `maxConcurrentAnalyses`, run **batch compute** across many project files, and close the client connection.
+
+- **Project lifecycle (`Model`)**: Save, save as, close, **run compute** (with optional timeout and partial-success handling), clear results, and automatic profile **generate** / **reset** when that feature is enabled on the project.
+
+- **Profiles (`model.Profiles`)**: List, create, copy, delete, and rename profiles; active profile; list soil layers and bedrock; output depths; get **SoilLayer** / **BedrockLayer** property proxies.
+
+- **Profile layer CRUD (`model.SoilLayers`)**: Insert, append, delete, duplicate, and move soil layers on the active profile.
+
+- **Mean profile (`model.MeanProfile`)**: Structure CRUD on the automatic-generation template; **MeanProfileSoilLayer** properties including vary-with-depth shear wave / shear strength tables and **ReferenceCurve** (without auto-generate on template layers).
+
+- **Profile generation settings (`model.ProfileGenerationSettings`)**: Typed getters/setters for randomization, profile count, and related generation parameters.
+
+- **Project settings (`model.ProjectSettings`)**: Typed project properties (analysis mode, solver, motions configuration, automatic profile generation, etc.), plus **unit system** get/change.
+
+- **Ground motions (`model.Motions`)**: Motion directory preferences (add/remove/list), refresh project motion list, **uni-directional** motion list/selection or **bi-directional** pair list/selection, select-all and per-directory select/deselect.
+
+- **Layer properties**: **SoilLayer** (thickness, soil model, unit weight, …), **ReferenceCurve** (curve model, points, generate reference curve on profile layers), **SoilLayerCurve** (dynamics, discrete points, **curve fit** via `FittingProcedureModel`), **BedrockLayer** on realized profiles.
+
+- **Results (`model.Results`)**: Result paths and database metadata; compute-aligned motion/layer discovery; **pandas DataFrames** for profile/layer time histories, profile summaries, result series (`ResultSeriesKind`), strain convergence, and real-time displacement; bulk fetch helpers for many motions/layers.
+
+- **Public types and enums**: Summary dataclasses (`ProfileSummary`, `MotionInfo`, `ResultDatabaseInfo`, …), `ResultSeriesKind`, `ResultMotionType`, `UnitSystem`, and property enums under `rsseismic.enums` (for example `SoilModel`, `AnalysisMode`, `InputMotionConfiguration`, `FittingProcedureModel`).
+
+RPC failures raise **`ScriptingError`**. Some successful RPCs carry advisory text in `errorMessage`; the client logs those as **warnings** (for example duplicate motion directory add).
+
+For method-level detail, use the [Scripting reference manual](https://rocscience.github.io/rsseismic-scripting/) (API reference and example scripts).
+
+## Getting Started
+
+- **Tutorials and workflows (Rocscience Help):** https://www.rocscience.com/help/rsseismic/tutorials/
+- **Product documentation:** https://www.rocscience.com/help/rsseismic/documentation/

rsseismicscripting-3.0.0/src/RSSeismicScripting.egg-info/SOURCES.txt

@@ -0,0 +1,125 @@
+License.txt
+README.md
+pyproject.toml
+src/RSSeismicScripting.egg-info/PKG-INFO
+src/RSSeismicScripting.egg-info/SOURCES.txt
+src/RSSeismicScripting.egg-info/dependency_links.txt
+src/RSSeismicScripting.egg-info/requires.txt
+src/RSSeismicScripting.egg-info/top_level.txt
+src/rsseismic/Application.py
+src/rsseismic/ApplicationManager.py
+src/rsseismic/BedrockLayer.py
+src/rsseismic/MeanProfile.py
+src/rsseismic/MeanProfileSoilLayer.py
+src/rsseismic/Model.py
+src/rsseismic/Motions.py
+src/rsseismic/ProfileGenerationSettings.py
+src/rsseismic/Profiles.py
+src/rsseismic/ProjectSettings.py
+src/rsseismic/ReferenceCurve.py
+src/rsseismic/Results.py
+src/rsseismic/SoilLayer.py
+src/rsseismic/SoilLayerCurve.py
+src/rsseismic/SoilLayerOperations.py
+src/rsseismic/__init__.py
+src/rsseismic/_application_paths.py
+src/rsseismic/_batch_compute.py
+src/rsseismic/_client.py
+src/rsseismic/_proto_converters.py
+src/rsseismic/_proxyObject.py
+src/rsseismic/_result_bulk_dataframes.py
+src/rsseismic/_result_dataframes.py
+src/rsseismic/_rpc_helpers.py
+src/rsseismic/exceptions.py
+src/rsseismic/types.py
+src/rsseismic/enums/__init__.py
+src/rsseismic/enums/_generated.py
+src/rsseismic/enums/fitting_procedure.py
+src/rsseismic/generatedFiles/ApplicationService_pb2.py
+src/rsseismic/generatedFiles/ApplicationService_pb2.pyi
+src/rsseismic/generatedFiles/ApplicationService_pb2_grpc.py
+src/rsseismic/generatedFiles/BedrockLayerDataService_pb2.py
+src/rsseismic/generatedFiles/BedrockLayerDataService_pb2.pyi
+src/rsseismic/generatedFiles/BedrockLayerDataService_pb2_grpc.py
+src/rsseismic/generatedFiles/CommonMessages_pb2.py
+src/rsseismic/generatedFiles/CommonMessages_pb2.pyi
+src/rsseismic/generatedFiles/CommonMessages_pb2_grpc.py
+src/rsseismic/generatedFiles/MeanProfileService_pb2.py
+src/rsseismic/generatedFiles/MeanProfileService_pb2.pyi
+src/rsseismic/generatedFiles/MeanProfileService_pb2_grpc.py
+src/rsseismic/generatedFiles/MeanProfileSoilLayerDataService_pb2.py
+src/rsseismic/generatedFiles/MeanProfileSoilLayerDataService_pb2.pyi
+src/rsseismic/generatedFiles/MeanProfileSoilLayerDataService_pb2_grpc.py
+src/rsseismic/generatedFiles/ModelService_pb2.py
+src/rsseismic/generatedFiles/ModelService_pb2.pyi
+src/rsseismic/generatedFiles/ModelService_pb2_grpc.py
+src/rsseismic/generatedFiles/MotionService_pb2.py
+src/rsseismic/generatedFiles/MotionService_pb2.pyi
+src/rsseismic/generatedFiles/MotionService_pb2_grpc.py
+src/rsseismic/generatedFiles/ProfileGenerationSettingsService_pb2.py
+src/rsseismic/generatedFiles/ProfileGenerationSettingsService_pb2.pyi
+src/rsseismic/generatedFiles/ProfileGenerationSettingsService_pb2_grpc.py
+src/rsseismic/generatedFiles/ProfileService_pb2.py
+src/rsseismic/generatedFiles/ProfileService_pb2.pyi
+src/rsseismic/generatedFiles/ProfileService_pb2_grpc.py
+src/rsseismic/generatedFiles/ProjectSettingsDataService_pb2.py
+src/rsseismic/generatedFiles/ProjectSettingsDataService_pb2.pyi
+src/rsseismic/generatedFiles/ProjectSettingsDataService_pb2_grpc.py
+src/rsseismic/generatedFiles/ReferenceCurveDataService_pb2.py
+src/rsseismic/generatedFiles/ReferenceCurveDataService_pb2.pyi
+src/rsseismic/generatedFiles/ReferenceCurveDataService_pb2_grpc.py
+src/rsseismic/generatedFiles/ResultsService_pb2.py
+src/rsseismic/generatedFiles/ResultsService_pb2.pyi
+src/rsseismic/generatedFiles/ResultsService_pb2_grpc.py
+src/rsseismic/generatedFiles/SoilLayerCurveDataService_pb2.py
+src/rsseismic/generatedFiles/SoilLayerCurveDataService_pb2.pyi
+src/rsseismic/generatedFiles/SoilLayerCurveDataService_pb2_grpc.py
+src/rsseismic/generatedFiles/SoilLayerDataService_pb2.py
+src/rsseismic/generatedFiles/SoilLayerDataService_pb2.pyi
+src/rsseismic/generatedFiles/SoilLayerDataService_pb2_grpc.py
+src/rsseismic/generatedFiles/SoilLayerService_pb2.py
+src/rsseismic/generatedFiles/SoilLayerService_pb2.pyi
+src/rsseismic/generatedFiles/SoilLayerService_pb2_grpc.py
+src/rsseismic/generatedFiles/__init__.py
+src/rsseismic/properties/_PropertyAccessor.py
+src/rsseismic/properties/__init__.py
+src/rsseismic/properties/bedrockLayer/__init__.py
+src/rsseismic/properties/bedrockLayer/_generated.py
+src/rsseismic/properties/meanProfileSoilLayer/__init__.py
+src/rsseismic/properties/meanProfileSoilLayer/_generated.py
+src/rsseismic/properties/profileGenerationSettings/__init__.py
+src/rsseismic/properties/profileGenerationSettings/_generated.py
+src/rsseismic/properties/projectSettings/__init__.py
+src/rsseismic/properties/projectSettings/_generated.py
+src/rsseismic/properties/referenceCurve/__init__.py
+src/rsseismic/properties/referenceCurve/_generated.py
+src/rsseismic/properties/soilLayer/__init__.py
+src/rsseismic/properties/soilLayer/_generated.py
+tests/test_application_manager.py
+tests/test_auto_profile_workflow.py
+tests/test_batch_compute.py
+tests/test_bedrock_layer.py
+tests/test_connection.py
+tests/test_fem_verification_workflow.py
+tests/test_generated_enums.py
+tests/test_generated_property_enums.py
+tests/test_mean_profile.py
+tests/test_mean_profile_soil_layer.py
+tests/test_model_generate_profiles.py
+tests/test_model_run_compute.py
+tests/test_motions.py
+tests/test_multi_open_scripting.py
+tests/test_profile_generation_settings.py
+tests/test_profiles.py
+tests/test_project_settings.py
+tests/test_reference_curve.py
+tests/test_result_bulk_dataframes.py
+tests/test_result_bulk_dataframes_integration.py
+tests/test_result_dataframes.py
+tests/test_results.py
+tests/test_results_dataframes_integration.py
+tests/test_rpc_helpers.py
+tests/test_single_profile_workflow.py
+tests/test_soil_layer.py
+tests/test_soil_layer_curve.py
+tests/test_soil_layer_operations.py

rsseismicscripting-3.0.0/src/RSSeismicScripting.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rsseismicscripting-3.0.0/src/RSSeismicScripting.egg-info/requires.txt

@@ -0,0 +1,4 @@
+grpcio>=1.64.1
+protobuf<6.0
+pandas>=2.0
+matplotlib>=3.7

rsseismicscripting-3.0.0/src/RSSeismicScripting.egg-info/top_level.txt

@@ -0,0 +1 @@
+rsseismic

rsseismicscripting-3.0.0/src/rsseismic/Application.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import logging
+
+from rsseismic._application_paths import getInstalledExecutablePath
+from rsseismic._client import Client, DEFAULT_SCRIPTING_PORT
+from rsseismic.ApplicationManager import ApplicationManager
+from rsseismic._rpc_helpers import require_success
+from rsseismic.exceptions import ScriptingError
+from rsseismic.generatedFiles import ApplicationService_pb2 as ApplicationService_pb2
+from rsseismic.generatedFiles import ApplicationService_pb2_grpc as ApplicationService_pb2_grpc
+from rsseismic._batch_compute import (
+    BatchComputeJobResult,
+    BatchComputeResult,
+    run_batch_compute,
+)
+from rsseismic.Model import Model
+
+
+class RSSeismicApplication:
+    """
+    Entry point for connecting to a running RSSeismic scripting server.
+
+    Mirrors RS3's RS3Modeler: connect on a port, open projects, return Model proxies.
+    Use startApplication() to launch RSSeismic with -startScriptingServer when it is
+    not already running.
+    """
+
+    def __init__(self, port: int = DEFAULT_SCRIPTING_PORT, host: str = "localhost"):
+        self._client = Client(port=port, host=host)
+        self._port = port
+        self._host = host
+
+    @property
+    def port(self) -> int:
+        return self._port
+
+    @property
+    def client(self) -> Client:
+        return self._client
+
+    @classmethod
+    def startApplication(
+        cls,
+        port: int = DEFAULT_SCRIPTING_PORT,
+        overridePathToExecutable: str | None = None,
+        timeout: float = ApplicationManager.defaultTimeout,
+    ) -> None:
+        """
+        Launch RSSeismic and wait until the scripting server on port accepts ping.
+
+        Args:
+            port: Scripting port (49152–65535). Same value as DEFAULT_SCRIPTING_PORT / 60058.
+            overridePathToExecutable: Full path to RSSeismic.exe. When omitted, the latest
+                RSSeismic install is resolved from the Windows registry.
+            timeout: Seconds to wait for the server to become reachable.
+
+        Raises:
+            ValueError: port out of range
+            RuntimeError: port occupied, executable not found, or registry lookup failed
+            TimeoutError: server not ready within timeout
+        """
+        executable_path = (
+            overridePathToExecutable
+            if overridePathToExecutable
+            else getInstalledExecutablePath()
+        )
+        app_manager = ApplicationManager()
+        app_logger = logging.getLogger("Rocscience.RSSeismic")
+        app_manager.startApplication(
+            executable_path,
+            port,
+            cls._verifyServerRunning,
+            app_logger,
+            timeout,
+        )
+
+    @staticmethod
+    def _verifyServerRunning(port: int) -> None:
+        client = Client(port=port)
+        try:
+            client.ping()
+        finally:
+            client.closeConnection()
+
+    def ping(self) -> None:
+        """Verify the scripting server is reachable."""
+        self._client.ping()
+
+    def getMaxConcurrentAnalyses(self) -> int:
+        """
+        Return the effective maxConcurrentAnalyses from RSSeismic preferences.
+
+        This is the within-project cap on simultaneous engine runs used during
+        RunCompute. Batch parallel_degree capping uses this value when available.
+        """
+        stub = ApplicationService_pb2_grpc.ApplicationServiceStub(self._client.channel)
+        request = ApplicationService_pb2.GetMaxConcurrentAnalysesRequest()
+        response = self._client.callFunction(stub.GetMaxConcurrentAnalyses, request)
+        return int(response.maxConcurrentAnalyses)
+
+    def setMaxConcurrentAnalyses(self, maxConcurrentAnalyses: int) -> int:
+        """
+        Set maxConcurrentAnalyses in RSSeismic preferences (within-project engine cap).
+
+        Values are clamped to 1..256, matching the Preferences UI. Returns the effective
+        value after save (same semantics as getMaxConcurrentAnalyses).
+        """
+        stub = ApplicationService_pb2_grpc.ApplicationServiceStub(self._client.channel)
+        request = ApplicationService_pb2.SetMaxConcurrentAnalysesRequest(
+            maxConcurrentAnalyses=maxConcurrentAnalyses,
+        )
+        response = self._client.callFunction(stub.SetMaxConcurrentAnalyses, request)
+
+        if not response.success:
+            raise ScriptingError(
+                response.errorMessage or "SetMaxConcurrentAnalyses failed."
+            )
+
+        return int(response.maxConcurrentAnalyses)
+
+    def openFile(self, path: str) -> Model:
+        """Open a DeepSoil project file and return a Model handle."""
+        stub = ApplicationService_pb2_grpc.ApplicationServiceStub(self._client.channel)
+        request = ApplicationService_pb2.OpenFileRequest(fileName=path)
+        response = self._client.callFunction(stub.OpenFile, request)
+        require_success(response, "OpenFile")
+
+        if not response.modelID:
+            raise ScriptingError("OpenFile succeeded but returned an empty modelID.")
+
+        return Model(self._client, response.modelID)
+
+    def newProject(self) -> Model:
+        """Create a blank project with default settings and return a Model handle."""
+        stub = ApplicationService_pb2_grpc.ApplicationServiceStub(self._client.channel)
+        request = ApplicationService_pb2.NewProjectRequest()
+        response = self._client.callFunction(stub.NewProject, request)
+
+        if not response.success:
+            raise ScriptingError("NewProject failed.")
+
+        if not response.modelID:
+            raise ScriptingError("NewProject succeeded but returned an empty modelID.")
+
+        return Model(self._client, response.modelID)
+
+    def runBatchCompute(
+        self,
+        file_paths: list[str],
+        motion_names: list[str] | None = None,
+        *,
+        parallel_degree: int = 1,
+        max_concurrent_analyses: int | None = None,
+        timeout: float | None = None,
+        close_save_project: bool = False,
+        continue_on_error: bool = True,
+    ) -> BatchComputeResult:
+        """
+        Run compute for many project files (open → motion selection → compute → close).
+
+        Motion selection applies to the open session only; it is not stored in the
+        project file. Each job calls setMotionSelection before runCompute.
+
+        Args:
+            file_paths: Project files to process (.rsseismicfile). Duplicate paths are omitted.
+            motion_names: Motions to select for every project. When None, each project keeps
+                its current selection or uses the first available motion.
+            parallel_degree: How many projects may run at once (cross-project only). Capped
+                using maxConcurrentAnalyses from RSSeismic preferences when available.
+            max_concurrent_analyses: When set, applies this within-project engine cap for the
+                batch via setMaxConcurrentAnalyses and restores the previous preference after
+                the batch. When None, uses getMaxConcurrentAnalyses().
+            timeout: Optional RunCompute deadline in seconds for each project.
+            close_save_project: When True, save each project on close.
+            continue_on_error: When False, stop starting new jobs after the first failure
+                (in-flight jobs may still finish).
+
+        Returns:
+            BatchComputeResult with per-file outcomes in input order.
+        """
+        return run_batch_compute(
+            self,
+            file_paths,
+            motion_names,
+            parallel_degree=parallel_degree,
+            max_concurrent_analyses=max_concurrent_analyses,
+            timeout=timeout,
+            close_save_project=close_save_project,
+            continue_on_error=continue_on_error,
+            logger=logging.getLogger("Rocscience.RSSeismic"),
+        )
+
+    def close(self) -> None:
+        """Close the gRPC connection."""
+        self._client.closeConnection()