subscript 1.14.6__tar.gz → 1.14.7__tar.gz

{subscript-1.14.6 → subscript-1.14.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subscript
-Version: 1.14.6
+Version: 1.14.7
 Summary: Equinor's collection of subsurface reservoir modelling scripts
 Author-email: Equinor <rnyb@equinor.com>
 License-Expression: GPL-3.0-only

{subscript-1.14.6 → subscript-1.14.7}/pyproject.toml

@@ -214,6 +214,7 @@ ignore = [
     "PLR0904", # too-many-public-methods
     "PLR1702", # too-many-nested-blocks
     "RUF067",  # non empty init module
+    "RUF069",  # unreliable-floating-point-equality
     "PLC1901",  # compare-to-empty-string
 ]
 

subscript-1.14.7/src/subscript/restartthinner/restartthinner.py

@@ -0,0 +1,249 @@
+"""Restart file (UNRST) thinner, command line application"""
+
+import argparse
+import datetime
+import logging
+import shutil
+import subprocess
+import tempfile
+from contextlib import chdir
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from resdata.resfile import ResdataFile
+
+from subscript import __version__, getLogger
+
+logger = getLogger(__name__)
+
+DESCRIPTION = """
+Slice a subset of restart-dates from an E100 Restart file (UNRST)
+
+Example::
+
+    $ restartthinner --restarts 4 ECLIPSE.UNRST
+
+where four restarts evenly spread out in relevant dates will be picked and
+written to the same filename (keeping the original is optional)
+"""
+
+
+def find_resdata_app(toolname: str) -> str:
+    """Locate path of resdata apps, trying common suffixes (.x, .c.x, .cpp.x).
+
+    Args:
+        toolname: Base name of the tool (e.g., 'rd_unpack')
+
+    Returns:
+        Full path to the executable.
+
+    Raises:
+        OSError: If tool cannot be found in PATH.
+    """
+    for ext in [".x", ".c.x", ".cpp.x", ""]:  # Order matters.
+        if path := shutil.which(toolname + ext):
+            return path
+    raise OSError(f"{toolname} not found in PATH")
+
+
+def date_slicer(
+    slicedates: list[pd.Timestamp],
+    restartdates: list[datetime.datetime],
+    restartindices: list[int],
+) -> list[int]:
+    """Make a list of report indices that match the input slicedates."""
+    slicedatelist = []
+    for slicedate in slicedates:
+        daydistances = [abs((pd.Timestamp(slicedate) - x).days) for x in restartdates]
+        slicedatelist.append(restartindices[daydistances.index(min(daydistances))])
+    return slicedatelist
+
+
+def rd_repacker(rstfilename: str, slicerstindices: list[int], quiet: bool) -> None:
+    """Repack a UNRST file keeping only selected restart indices.
+
+    Uses rd_unpack and rd_pack utilities from resdata to unpack the UNRST file,
+    remove unwanted dates, and repack into a new UNRST file.
+
+    Args:
+        rstfilename: Path to the UNRST file.
+        slicerstindices: List of restart indices to keep.
+        quiet: If True, suppress subprocess output.
+
+    Raises:
+        OSError: If rd_unpack or rd_pack tools are not found.
+    """
+    rd_unpack = find_resdata_app("rd_unpack")
+    rd_pack = find_resdata_app("rd_pack")
+
+    rstpath = Path(rstfilename)
+    rstdir = rstpath.parent or Path(".")
+    rstname = rstpath.name
+
+    with chdir(rstdir):
+        tempdir = Path(tempfile.mkdtemp(dir="."))
+        try:
+            # Move UNRST into temp directory and work there
+            shutil.move(rstname, tempdir / rstname)
+
+            with chdir(tempdir):
+                subprocess.run(
+                    [rd_unpack, rstname],
+                    stdout=subprocess.DEVNULL if quiet else None,
+                    check=True,
+                )
+
+                for file in Path(".").glob("*.X*"):
+                    index = int(file.suffix.lstrip(".X"))
+                    if index not in slicerstindices:
+                        file.unlink()
+
+                remaining_files = sorted(Path(".").glob("*.X*"))
+                subprocess.run(
+                    [rd_pack, *[str(f) for f in remaining_files]],
+                    stdout=subprocess.DEVNULL if quiet else None,
+                    check=True,
+                )
+
+                # Move result back up
+                shutil.move(rstname, Path("..") / rstname)
+        finally:
+            shutil.rmtree(tempdir)
+
+
+def get_restart_indices(rstfilename: str) -> list[int]:
+    """Extract a list of restart indices for a filename.
+
+    Args:
+        rstfilename: Path to the UNRST file.
+
+    Returns:
+        List of restart report indices.
+
+    Raises:
+        FileNotFoundError: If the file does not exist.
+    """
+    if Path(rstfilename).exists():
+        # This function segfaults if file does not exist
+        return ResdataFile.file_report_list(str(rstfilename))
+    raise FileNotFoundError(f"{rstfilename} not found")
+
+
+def restartthinner(
+    filename: str,
+    numberofslices: int,
+    quiet: bool = False,
+    dryrun: bool = True,
+    keep: bool = False,
+) -> None:
+    """Thin an existing UNRST file to selected number of restarts.
+
+    Args:
+        filename: Path to the UNRST file.
+        numberofslices: Number of restart dates to keep.
+        quiet: If True, suppress informational output.
+        dryrun: If True, only show what would be done without modifying files.
+        keep: If True, keep original file with .orig suffix.
+    """
+    rst = ResdataFile(filename)
+    restart_indices = get_restart_indices(filename)
+    restart_dates = [
+        rst.iget_restart_sim_time(index) for index in range(len(restart_indices))
+    ]
+
+    if numberofslices > 1:
+        slicedates = pd.DatetimeIndex(
+            np.linspace(
+                pd.Timestamp(restart_dates[0]).value,
+                pd.Timestamp(restart_dates[-1]).value,
+                int(numberofslices),
+            )
+        ).to_list()
+    else:
+        slicedates = [restart_dates[-1]]  # Only return last date if only one is wanted
+
+    slicerstindices = date_slicer(slicedates, restart_dates, restart_indices)
+    slicerstindices = sorted(set(slicerstindices))  # uniquify
+
+    if not quiet:
+        logger.info("Selected restarts:")
+        logger.info("-----------------------")
+        for idx, rstidx in enumerate(restart_indices):
+            slicepresent = "X" if rstidx in slicerstindices else ""
+            logger.info(
+                "%4d  %s  %s",
+                rstidx,
+                datetime.date.strftime(restart_dates[idx], "%Y-%m-%d"),
+                slicepresent,
+            )
+        logger.info("-----------------------")
+
+    if not dryrun:
+        if keep:
+            backupname = filename + ".orig"
+            logger.info("Backing up %s to %s", filename, backupname)
+            shutil.copyfile(filename, backupname)
+        rd_repacker(filename, slicerstindices, quiet)
+        logger.info("Written to %s", filename)
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Setup parser"""
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter, description=DESCRIPTION
+    )
+    parser.add_argument("UNRST", help="Name of UNRST file")
+    parser.add_argument(
+        "-n",
+        "--restarts",
+        type=int,
+        help="Number of restart dates wanted",
+        required=True,
+    )
+    parser.add_argument(
+        "-d",
+        "--dryrun",
+        action="store_true",
+        default=False,
+        help="Dry-run only, do not touch files",
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        default=False,
+        help="Mute output from script",
+    )
+    parser.add_argument(
+        "-k",
+        "--keep",
+        action="store_true",
+        default=False,
+        help="Keep original UNRST file",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s (subscript version " + __version__ + ")",
+    )
+    return parser
+
+
+def main() -> None:
+    """Endpoint for command line script."""
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.restarts <= 0:
+        parser.error("Number of restarts must be a positive number")
+    if args.UNRST.endswith(".DATA"):
+        parser.error("Provide the UNRST file, not the DATA file")
+    if args.quiet:
+        logger.setLevel(logging.WARNING)
+
+    restartthinner(args.UNRST, args.restarts, args.quiet, args.dryrun, args.keep)
+
+
+if __name__ == "__main__":
+    main()

{subscript-1.14.6 → subscript-1.14.7}/src/subscript/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.14.6'
-__version_tuple__ = version_tuple = (1, 14, 6)
+__version__ = version = '1.14.7'
+__version_tuple__ = version_tuple = (1, 14, 7)
 
-__commit_id__ = commit_id = 'g4ac49d50d'
+__commit_id__ = commit_id = 'g88003f2b0'

{subscript-1.14.6 → subscript-1.14.7}/src/subscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subscript
-Version: 1.14.6
+Version: 1.14.7
 Summary: Equinor's collection of subsurface reservoir modelling scripts
 Author-email: Equinor <rnyb@equinor.com>
 License-Expression: GPL-3.0-only

subscript-1.14.7/tests/test_restartthinner.py

@@ -0,0 +1,222 @@
+import datetime
+import logging
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from unittest.mock import patch
+
+import pandas as pd
+import pytest
+
+from subscript.restartthinner import restartthinner
+
+ECLDIR = Path(__file__).absolute().parent / "data/reek/eclipse/model"
+
+UNRST_FNAME = "2_R001_REEK-0.UNRST"
+
+
+def test_dryrun(tmp_path, mocker, monkeypatch):
+    """Test dry-run"""
+    shutil.copyfile(ECLDIR / UNRST_FNAME, tmp_path / UNRST_FNAME)
+
+    monkeypatch.chdir(tmp_path)
+
+    orig_rstindices = restartthinner.get_restart_indices(UNRST_FNAME)
+    assert len(orig_rstindices) == 4
+
+    mocker.patch("sys.argv", ["restartthinner", "-d", "-n", "2", UNRST_FNAME])
+    restartthinner.main()
+
+    # Check that dry run did not do anything
+    assert Path(UNRST_FNAME).exists()
+    assert len(orig_rstindices) == len(restartthinner.get_restart_indices(UNRST_FNAME))
+
+
+def test_first_and_last(tmp_path, mocker, monkeypatch):
+    """Ask for two restart points, this should give us the first and last."""
+    shutil.copyfile(ECLDIR / UNRST_FNAME, tmp_path / UNRST_FNAME)
+
+    monkeypatch.chdir(tmp_path)
+
+    orig_rstindices = restartthinner.get_restart_indices(UNRST_FNAME)
+
+    mocker.patch("sys.argv", ["restartthinner", "-n", "2", UNRST_FNAME, "--keep"])
+    restartthinner.main()
+
+    assert Path(UNRST_FNAME).exists()
+    assert Path(UNRST_FNAME + ".orig").exists()  # The backed up file
+
+    new_rstindices = restartthinner.get_restart_indices(UNRST_FNAME)
+    assert len(new_rstindices) == 2
+    assert new_rstindices[0] == orig_rstindices[0]
+    assert new_rstindices[-1] == orig_rstindices[-1]
+    assert len(restartthinner.get_restart_indices(UNRST_FNAME + ".orig")) == 4
+
+
+def test_subdirectory(tmp_path, mocker, monkeypatch):
+    """Check that we can thin an UNRST file two directory levels down"""
+    monkeypatch.chdir(tmp_path)
+
+    subdir = Path("eclipse/model")
+    subdir.mkdir(parents=True)
+
+    shutil.copyfile(ECLDIR / UNRST_FNAME, subdir / UNRST_FNAME)
+    orig_rstindices = restartthinner.get_restart_indices(subdir / UNRST_FNAME)
+
+    mocker.patch(
+        "sys.argv", ["restartthinner", "-n", "3", str(subdir / UNRST_FNAME), "--keep"]
+    )
+    print(os.getcwd())
+    restartthinner.main()
+    print(os.getcwd())
+
+    assert (subdir / UNRST_FNAME).exists()
+    assert (subdir / (UNRST_FNAME + ".orig")).exists()  # The backed up file
+
+    new_rstindices = restartthinner.get_restart_indices(subdir / UNRST_FNAME)
+    assert len(new_rstindices) == 3
+    assert new_rstindices[0] == orig_rstindices[0]
+    assert new_rstindices[-1] == orig_rstindices[-1]
+    assert (
+        len(restartthinner.get_restart_indices(subdir / (UNRST_FNAME + ".orig"))) == 4
+    )
+
+
+def test_get_restart_indices_filenotfound(tmp_path, monkeypatch):
+    """EclFile.file_report_list segfaults unless the code is careful"""
+    with pytest.raises(FileNotFoundError, match="foo"):
+        restartthinner.get_restart_indices("foo")
+    with pytest.raises(FileNotFoundError, match="foo"):
+        restartthinner.get_restart_indices(Path("foo"))
+
+    monkeypatch.chdir(tmp_path)
+    Path("FOO.UNRST").write_text("this is not an unrst file", encoding="utf8")
+    with pytest.raises(TypeError, match="which is not a restart file"):
+        restartthinner.get_restart_indices("FOO.UNRST")
+
+
+@pytest.mark.integration
+def test_integration():
+    """Test that the endpoint is installed, and the binary tools are available"""
+    assert subprocess.check_output(["restartthinner", "-h"])
+
+
+def test_single_restart_slice(tmp_path, mocker, monkeypatch):
+    """Test requesting only 1 restart (should return just the last date)."""
+    shutil.copyfile(ECLDIR / UNRST_FNAME, tmp_path / UNRST_FNAME)
+    monkeypatch.chdir(tmp_path)
+
+    orig_rstindices = restartthinner.get_restart_indices(UNRST_FNAME)
+
+    mocker.patch("sys.argv", ["restartthinner", "-n", "1", UNRST_FNAME])
+    restartthinner.main()
+
+    new_rstindices = restartthinner.get_restart_indices(UNRST_FNAME)
+    assert len(new_rstindices) == 1
+    assert new_rstindices[0] == orig_rstindices[-1]  # Should be the last date
+
+
+def test_negative_restarts_error(tmp_path, mocker, capsys, monkeypatch):
+    """Test that negative restart count gives an error."""
+    shutil.copyfile(ECLDIR / UNRST_FNAME, tmp_path / UNRST_FNAME)
+    monkeypatch.chdir(tmp_path)
+
+    mocker.patch("sys.argv", ["restartthinner", "-n", "-1", UNRST_FNAME])
+    with pytest.raises(SystemExit) as excinfo:
+        restartthinner.main()
+
+    assert excinfo.value.code == 2  # argparse error exit code
+    captured = capsys.readouterr()
+    assert "positive number" in captured.err
+
+
+def test_zero_restarts_error(tmp_path, mocker, capsys, monkeypatch):
+    """Test that zero restart count gives an error."""
+    shutil.copyfile(ECLDIR / UNRST_FNAME, tmp_path / UNRST_FNAME)
+    monkeypatch.chdir(tmp_path)
+
+    mocker.patch("sys.argv", ["restartthinner", "-n", "0", UNRST_FNAME])
+    with pytest.raises(SystemExit) as excinfo:
+        restartthinner.main()
+
+    assert excinfo.value.code == 2
+    captured = capsys.readouterr()
+    assert "positive number" in captured.err
+
+
+def test_data_file_error(tmp_path, mocker, capsys, monkeypatch):
+    """Test that providing a DATA file instead of UNRST gives an error."""
+    monkeypatch.chdir(tmp_path)
+    Path("TEST.DATA").touch()
+
+    mocker.patch("sys.argv", ["restartthinner", "-n", "2", "TEST.DATA"])
+    with pytest.raises(SystemExit) as excinfo:
+        restartthinner.main()
+
+    assert excinfo.value.code == 2
+    captured = capsys.readouterr()
+    assert "UNRST file" in captured.err
+
+
+def test_find_resdata_app_not_found():
+    """Test that OSError is raised when resdata tools are not in PATH."""
+    with (
+        patch.object(shutil, "which", return_value=None),
+        pytest.raises(OSError, match="nonexistent_tool not found in PATH"),
+    ):
+        restartthinner.find_resdata_app("nonexistent_tool")
+
+
+def test_find_resdata_app_with_suffix():
+    """Test that find_resdata_app tries different suffixes."""
+    call_count = {"count": 0}
+
+    def mock_which(name):
+        call_count["count"] += 1
+        # Simulate finding tool with .c.x suffix on second try
+        if name == "rd_unpack.c.x":
+            return "/usr/bin/rd_unpack.c.x"
+        return None
+
+    with patch.object(shutil, "which", side_effect=mock_which):
+        result = restartthinner.find_resdata_app("rd_unpack")
+        assert result == "/usr/bin/rd_unpack.c.x"
+        assert call_count["count"] == 2  # Tried .x first, then .c.x
+
+
+def test_date_slicer():
+    """Test date_slicer matches slicedates to nearest restart dates."""
+
+    # Create test data with 4 restart dates
+    restart_dates = [
+        datetime.datetime(2020, 1, 1),
+        datetime.datetime(2020, 4, 1),
+        datetime.datetime(2020, 7, 1),
+        datetime.datetime(2020, 10, 1),
+    ]
+    restart_indices = [0, 1, 2, 3]
+
+    # Slice dates that should match to indices 0, 2, 3
+    slice_dates = [
+        pd.Timestamp("2020-01-15"),  # Closest to Jan 1 -> index 0
+        pd.Timestamp("2020-06-15"),  # Closest to Jul 1 -> index 2
+        pd.Timestamp("2020-11-01"),  # Closest to Oct 1 -> index 3
+    ]
+
+    result = restartthinner.date_slicer(slice_dates, restart_dates, restart_indices)
+    assert result == [0, 2, 3]
+
+
+def test_quiet_mode(tmp_path, mocker, caplog, monkeypatch):
+    """Test that quiet mode suppresses log output."""
+    shutil.copyfile(ECLDIR / UNRST_FNAME, tmp_path / UNRST_FNAME)
+    monkeypatch.chdir(tmp_path)
+
+    # Run with quiet mode
+    with caplog.at_level(logging.INFO, logger="subscript"):
+        mocker.patch("sys.argv", ["restartthinner", "-q", "-n", "2", UNRST_FNAME])
+        restartthinner.main()
+
+    # Check that log output is empty
+    assert len(caplog.text) == 0