RSSeismicScripting 3.0.0__py3-none-any.whl

rsseismic/__init__.py

@@ -0,0 +1,79 @@
+import logging
+
+logger = logging.getLogger("Rocscience.RSSeismic")
+logger.setLevel(logging.INFO)
+
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setLevel(logging.INFO)
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    )
+    logger.addHandler(handler)
+
+from rsseismic._batch_compute import BatchComputeJobResult, BatchComputeResult
+from rsseismic.Application import RSSeismicApplication
+from rsseismic.Model import Model, RunComputeResult
+from rsseismic.Results import Results
+from rsseismic.types import (
+    ActiveProfile,
+    AppendLayersResult,
+    BedrockLayerSummary,
+    DeleteLayerResult,
+    DeleteProfileResult,
+    DiscretePoint,
+    DynamicsPoint,
+    GqHFittingLimits,
+    InsertLayerResult,
+    MotionInfo,
+    MotionPairInfo,
+    MoveLayerResult,
+    MeanProfileAppendLayersResult,
+    MeanProfileDeleteLayerResult,
+    MeanProfileInsertLayerResult,
+    MeanProfileMoveLayerResult,
+    MeanProfileSummary,
+    ProfileSummary,
+    ResultDatabaseInfo,
+    ResultLayerSummary,
+    ResultMotionSummary,
+    ResultMotionType,
+    ResultSeriesKind,
+    SoilLayerSummary,
+    UnitSystem,
+)
+
+__all__ = [
+    "RSSeismicApplication",
+    "BatchComputeJobResult",
+    "BatchComputeResult",
+    "Model",
+    "RunComputeResult",
+    "Results",
+    "DynamicsPoint",
+    "DiscretePoint",
+    "ProfileSummary",
+    "ActiveProfile",
+    "SoilLayerSummary",
+    "BedrockLayerSummary",
+    "DeleteProfileResult",
+    "MotionInfo",
+    "MotionPairInfo",
+    "ResultDatabaseInfo",
+    "ResultLayerSummary",
+    "ResultMotionSummary",
+    "ResultMotionType",
+    "ResultSeriesKind",
+    "InsertLayerResult",
+    "AppendLayersResult",
+    "DeleteLayerResult",
+    "MoveLayerResult",
+    "MeanProfileSummary",
+    "MeanProfileInsertLayerResult",
+    "MeanProfileAppendLayersResult",
+    "MeanProfileDeleteLayerResult",
+    "MeanProfileMoveLayerResult",
+    "GqHFittingLimits",
+    "UnitSystem",
+    "logger",
+]

rsseismic/_application_paths.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import os
+import sys
+
+
+def getInstalledExecutablePath() -> str:
+    """
+    Return the path to RSSeismic.exe from the Rocscience registry Install value.
+
+    Raises:
+        RuntimeError: on non-Windows or when no installation is found
+    """
+    if sys.platform != "win32":
+        raise RuntimeError(
+            "Automatic RSSeismic install lookup is only supported on Windows. "
+            "Pass overridePathToExecutable to startApplication()."
+        )
+
+    import winreg
+
+    candidates: list[tuple[str, str]] = []
+    for root in (winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER):
+        try:
+            rocscience_key = winreg.OpenKey(root, r"SOFTWARE\Rocscience")
+        except OSError:
+            continue
+
+        index = 0
+        while True:
+            try:
+                subkey_name = winreg.EnumKey(rocscience_key, index)
+            except OSError:
+                break
+            index += 1
+
+            if "rsseismic" not in subkey_name.casefold():
+                continue
+
+            try:
+                product_key = winreg.OpenKey(rocscience_key, subkey_name)
+                install_path, _ = winreg.QueryValueEx(product_key, "Install")
+                candidates.append((subkey_name, str(install_path)))
+            except OSError:
+                continue
+
+    if not candidates:
+        raise RuntimeError(
+            "Could not find an RSSeismic installation in the registry. "
+            "Pass overridePathToExecutable to startApplication()."
+        )
+
+    candidates.sort(key=lambda item: item[0], reverse=True)
+    for _, install_path in candidates:
+        executable = _executableFromInstallPath(install_path)
+        if executable is not None:
+            return executable
+
+    raise RuntimeError(
+        "Found RSSeismic registry entries but RSSeismic.exe was not present. "
+        "Pass overridePathToExecutable to startApplication()."
+    )
+
+
+def _executableFromInstallPath(install_path: str) -> str | None:
+    normalized = install_path.rstrip("\\/")
+    if normalized.casefold().endswith(".exe") and os.path.isfile(normalized):
+        return normalized
+
+    candidate = os.path.join(normalized, "RSSeismic.exe")
+    if os.path.isfile(candidate):
+        return candidate
+
+    return None

rsseismic/_batch_compute.py

@@ -0,0 +1,420 @@
+from __future__ import annotations
+
+import logging
+import os
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rsseismic.Model import Model, RunComputeResult
+
+if TYPE_CHECKING:
+    from rsseismic.Application import RSSeismicApplication
+
+
+@dataclass(frozen=True)
+class BatchComputeJobResult:
+    """Outcome of compute for one project in a batch."""
+
+    file_path: str
+    success: bool
+    partial_success: bool
+    error_message: str
+    motion_names: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class BatchComputeResult:
+    """Aggregate outcome of runBatchCompute."""
+
+    results: list[BatchComputeJobResult]
+    requested_parallel_degree: int
+    effective_parallel_degree: int
+
+    @property
+    def ok(self) -> bool:
+        """True when every job completed with full success (no partial failures)."""
+        return all(
+            job.success and not job.partial_success for job in self.results
+        )
+
+
+def resolve_parallel_degree(
+    requested: int,
+    job_count: int,
+    max_concurrent_analyses: int | None = None,
+) -> int:
+    """
+    Resolve cross-project concurrency for a batch.
+
+    Caps requested parallelism by job count and by logical CPU count divided by
+    the effective within-project engine cap (from RSSeismic preferences when available).
+    """
+    if not isinstance(requested, int):
+        raise TypeError("parallel_degree must be an int.")
+    if requested < 1:
+        raise ValueError("parallel_degree must be >= 1.")
+    if job_count < 1:
+        return 1
+
+    logical_cores = max(1, os.cpu_count() or 1)
+    if max_concurrent_analyses is not None and max_concurrent_analyses >= 1:
+        engines_per_project = max_concurrent_analyses
+    else:
+        engines_per_project = max(1, logical_cores // 2)
+
+    project_cap = max(1, logical_cores // engines_per_project)
+
+    return max(
+        1,
+        min(requested, job_count, project_cap),
+    )
+
+
+def _read_max_concurrent_analyses(app: RSSeismicApplication) -> int | None:
+    get_value = getattr(app, "getMaxConcurrentAnalyses", None)
+    if get_value is None:
+        return None
+
+    try:
+        value = int(get_value())
+    except Exception:
+        return None
+
+    if value < 1:
+        return None
+
+    return value
+
+
+def _configure_max_concurrent_analyses_for_batch(
+    app: RSSeismicApplication,
+    max_concurrent_analyses: int | None,
+) -> tuple[int | None, int | None]:
+    """
+    Apply optional maxConcurrentAnalyses override for a batch.
+
+    Returns (value for parallel_degree cap, original preference to restore).
+    """
+    if max_concurrent_analyses is None:
+        return _read_max_concurrent_analyses(app), None
+
+    set_value = getattr(app, "setMaxConcurrentAnalyses", None)
+    get_value = getattr(app, "getMaxConcurrentAnalyses", None)
+    if set_value is None or get_value is None:
+        return _read_max_concurrent_analyses(app), None
+
+    original = int(get_value())
+    set_value(max_concurrent_analyses)
+    return int(get_value()), original
+
+
+def _restore_max_concurrent_analyses(
+    app: RSSeismicApplication,
+    original: int | None,
+) -> None:
+    if original is None:
+        return
+
+    set_value = getattr(app, "setMaxConcurrentAnalyses", None)
+    if set_value is not None:
+        set_value(original)
+
+
+def normalize_batch_file_paths(
+    file_paths: list[str],
+    logger: logging.Logger | None = None,
+) -> list[str]:
+    """Return absolute, de-duplicated paths (case-insensitive on Windows)."""
+    seen: set[str] = set()
+    unique: list[str] = []
+
+    for raw_path in file_paths:
+        path = os.path.abspath(raw_path.strip())
+        key = os.path.normcase(path)
+        if key in seen:
+            if logger is not None:
+                logger.warning("Duplicate path omitted from batch: %s", path)
+            continue
+        seen.add(key)
+        unique.append(path)
+
+    return unique
+
+
+def normalize_motion_names(
+    motion_names: list[str] | None,
+    logger: logging.Logger | None = None,
+) -> list[str] | None:
+    """Return de-duplicated motion names (case-insensitive), preserving first occurrence."""
+    if motion_names is None:
+        return None
+
+    seen: set[str] = set()
+    unique: list[str] = []
+
+    for raw_name in motion_names:
+        name = raw_name.strip()
+        if not name:
+            if logger is not None:
+                logger.warning("Empty motion name omitted from batch.")
+            continue
+
+        key = name.casefold()
+        if key in seen:
+            if logger is not None:
+                logger.warning("Duplicate motion name omitted from batch: %s", name)
+            continue
+
+        seen.add(key)
+        unique.append(name)
+
+    return unique
+
+
+def resolve_motion_names(model: Model, motion_names: list[str] | None) -> list[str]:
+    """
+    Resolve motion selection for one batch job.
+
+    When motion_names is provided, every name must exist after refreshMotionsList.
+    When omitted, uses current project selection or the first available motion.
+    """
+    model.Motions.refreshMotionsList()
+    motions = model.Motions.listMotions()
+    if not motions:
+        raise RuntimeError(
+            "No motions available. Configure motion directories in RSSeismic "
+            "Preferences or ensure the project has motions."
+        )
+
+    available = {motion.name for motion in motions}
+
+    if motion_names:
+        missing = [name for name in motion_names if name not in available]
+        if missing:
+            raise RuntimeError(
+                "Motions not found in project: " + ", ".join(missing)
+            )
+        return list(motion_names)
+
+    selected = [motion.name for motion in motions if motion.isSelected]
+    if selected:
+        return selected
+
+    return [motions[0].name]
+
+
+def _run_single_batch_job(
+    app: RSSeismicApplication,
+    file_path: str,
+    motion_names: list[str] | None,
+    *,
+    timeout: float | None,
+    close_save_project: bool,
+) -> BatchComputeJobResult:
+    model: Model | None = None
+    try:
+        if not os.path.isfile(file_path):
+            return BatchComputeJobResult(
+                file_path=file_path,
+                success=False,
+                partial_success=False,
+                error_message=f"Project file not found: {file_path}",
+            )
+
+        model = app.openFile(file_path)
+        names = resolve_motion_names(model, motion_names)
+        model.Motions.setMotionSelection(names, selectOnlyListed=True)
+
+        compute_result: RunComputeResult = model.runCompute(timeout=timeout)
+        return BatchComputeJobResult(
+            file_path=file_path,
+            success=compute_result.success,
+            partial_success=compute_result.partialSuccess,
+            error_message=compute_result.errorMessage,
+            motion_names=tuple(names),
+        )
+    except Exception as ex:
+        return BatchComputeJobResult(
+            file_path=file_path,
+            success=False,
+            partial_success=False,
+            error_message=str(ex),
+        )
+    finally:
+        if model is not None:
+            model.close(saveProject=close_save_project)
+
+
+def _job_failed(job: BatchComputeJobResult) -> bool:
+    return not job.success or job.partial_success
+
+
+def run_batch_compute(
+    app: RSSeismicApplication,
+    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,
+    logger: logging.Logger | None = None,
+) -> BatchComputeResult:
+    """Run open → motion selection → compute → close for each project path."""
+    batch_logger = logger or logging.getLogger("Rocscience.RSSeismic")
+    normalized_paths = normalize_batch_file_paths(file_paths, batch_logger)
+    normalized_motion_names = normalize_motion_names(motion_names, batch_logger)
+
+    cap_max_concurrent_analyses, restore_max_concurrent_analyses = (
+        _configure_max_concurrent_analyses_for_batch(app, max_concurrent_analyses)
+    )
+    requested_parallel_degree = parallel_degree
+    effective_parallel_degree = resolve_parallel_degree(
+        parallel_degree,
+        len(normalized_paths),
+        cap_max_concurrent_analyses,
+    )
+
+    if effective_parallel_degree < requested_parallel_degree:
+        if cap_max_concurrent_analyses is not None:
+            batch_logger.warning(
+                "parallel_degree %s capped to %s (job_count=%s, maxConcurrentAnalyses=%s).",
+                requested_parallel_degree,
+                effective_parallel_degree,
+                len(normalized_paths),
+                cap_max_concurrent_analyses,
+            )
+        else:
+            batch_logger.warning(
+                "parallel_degree %s capped to %s (job_count=%s; maxConcurrentAnalyses unavailable).",
+                requested_parallel_degree,
+                effective_parallel_degree,
+                len(normalized_paths),
+            )
+
+    try:
+        if not normalized_paths:
+            return BatchComputeResult(
+                results=[],
+                requested_parallel_degree=requested_parallel_degree,
+                effective_parallel_degree=effective_parallel_degree,
+            )
+
+        if effective_parallel_degree == 1:
+            results = _run_batch_sequential(
+                app,
+                normalized_paths,
+                normalized_motion_names,
+                timeout=timeout,
+                close_save_project=close_save_project,
+                continue_on_error=continue_on_error,
+                stop_event=None,
+            )
+        else:
+            results = _run_batch_parallel(
+                app,
+                normalized_paths,
+                normalized_motion_names,
+                max_workers=effective_parallel_degree,
+                timeout=timeout,
+                close_save_project=close_save_project,
+                continue_on_error=continue_on_error,
+            )
+
+        return BatchComputeResult(
+            results=results,
+            requested_parallel_degree=requested_parallel_degree,
+            effective_parallel_degree=effective_parallel_degree,
+        )
+    finally:
+        _restore_max_concurrent_analyses(app, restore_max_concurrent_analyses)
+
+
+def _run_batch_sequential(
+    app: RSSeismicApplication,
+    file_paths: list[str],
+    motion_names: list[str] | None,
+    *,
+    timeout: float | None,
+    close_save_project: bool,
+    continue_on_error: bool,
+    stop_event: threading.Event | None,
+) -> list[BatchComputeJobResult]:
+    results: list[BatchComputeJobResult] = []
+
+    for file_path in file_paths:
+        if stop_event is not None and stop_event.is_set():
+            results.append(
+                BatchComputeJobResult(
+                    file_path=file_path,
+                    success=False,
+                    partial_success=False,
+                    error_message="Batch aborted after a prior failure.",
+                )
+            )
+            continue
+
+        job_result = _run_single_batch_job(
+            app,
+            file_path,
+            motion_names,
+            timeout=timeout,
+            close_save_project=close_save_project,
+        )
+        results.append(job_result)
+
+        if not continue_on_error and _job_failed(job_result):
+            if stop_event is not None:
+                stop_event.set()
+            break
+
+    return results
+
+
+def _run_batch_parallel(
+    app: RSSeismicApplication,
+    file_paths: list[str],
+    motion_names: list[str] | None,
+    *,
+    max_workers: int,
+    timeout: float | None,
+    close_save_project: bool,
+    continue_on_error: bool,
+) -> list[BatchComputeJobResult]:
+    stop_event = threading.Event()
+    results: list[BatchComputeJobResult | None] = [None] * len(file_paths)
+
+    def worker(index: int, file_path: str) -> None:
+        if stop_event.is_set():
+            results[index] = BatchComputeJobResult(
+                file_path=file_path,
+                success=False,
+                partial_success=False,
+                error_message="Batch aborted after a prior failure.",
+            )
+            return
+
+        job_result = _run_single_batch_job(
+            app,
+            file_path,
+            motion_names,
+            timeout=timeout,
+            close_save_project=close_save_project,
+        )
+        results[index] = job_result
+
+        if not continue_on_error and _job_failed(job_result):
+            stop_event.set()
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [
+            executor.submit(worker, index, file_path)
+            for index, file_path in enumerate(file_paths)
+        ]
+        for future in futures:
+            future.result()
+
+    return [result for result in results if result is not None]

rsseismic/_client.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import atexit
+import logging
+import os
+
+import grpc
+
+from rsseismic.generatedFiles import ApplicationService_pb2 as ApplicationService_pb2
+from rsseismic.generatedFiles import ApplicationService_pb2_grpc as ApplicationService_pb2_grpc
+
+# Product default when RSSeismic scripting server dialog opens (see App.DefaultScriptingPort in RSSeismic).
+DEFAULT_SCRIPTING_PORT = int(os.environ.get("RSSEISMIC_SCRIPTING_PORT", "60058"))
+
+_GRPC_MAX_MESSAGE_BYTES = 1024 * 1024 * 1024
+
+
+def _grpc_channel_options() -> list[tuple[str, int]]:
+    return [
+        ("grpc.max_receive_message_length", _GRPC_MAX_MESSAGE_BYTES),
+        ("grpc.max_send_message_length", _GRPC_MAX_MESSAGE_BYTES),
+    ]
+
+
+class Client:
+    """gRPC client for a running RSSeismic scripting server."""
+
+    def __init__(self, port: int = DEFAULT_SCRIPTING_PORT, host: str = "localhost"):
+        self.host = host
+        self.port = port
+        self.logger = logging.getLogger("Rocscience.RSSeismic")
+        self._establishConnection()
+        atexit.register(self.closeConnection)
+
+    @property
+    def channel(self) -> grpc.Channel:
+        if self._channel is None:
+            raise RuntimeError("gRPC channel is closed.")
+        return self._channel
+
+    def _establishConnection(self) -> None:
+        self._channel = grpc.insecure_channel(
+            f"{self.host}:{self.port}",
+            options=_grpc_channel_options(),
+        )
+
+    def closeConnection(self) -> None:
+        if getattr(self, "_channel", None) is not None:
+            self._channel.close()
+            self._channel = None
+
+    def ping(self) -> None:
+        stub = ApplicationService_pb2_grpc.ApplicationServiceStub(self.channel)
+        self.callFunction(stub.Ping, ApplicationService_pb2.PingRequest())
+
+    def callFunction(self, function, request, timeout: float | None = None):
+        try:
+            if timeout is not None:
+                response, call = function.with_call(request, timeout=timeout)
+            else:
+                response, call = function.with_call(request)
+            self._logTrailingMetadata(call)
+            return response
+        except grpc.RpcError:
+            self.logger.exception("An exception was raised from RSSeismic.")
+            raise
+
+    def _logTrailingMetadata(self, call) -> None:
+        if call is None:
+            return
+
+        for key, value in call.trailing_metadata():
+            if isinstance(value, bytes):
+                value = value.decode("utf-8")
+
+            if key == "warning-bin":
+                self.logger.warning(value)
+            elif key == "info-bin":
+                self.logger.info(value)
+            elif key == "debug-bin":
+                self.logger.debug(value)