xtgeo 4.10.1__cp312-cp312-win_amd64.whl → 4.12.0__cp312-cp312-win_amd64.whl

xtgeo/common/version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '4.10.1'
-__version_tuple__ = version_tuple = (4, 10, 1)
+__version__ = version = '4.12.0'
+__version_tuple__ = version_tuple = (4, 12, 0)
+
+__commit_id__ = commit_id = 'g4f136d221'

xtgeo/cube/_cube_window_attributes.py

@@ -63,6 +63,7 @@ class CubeAttrs:
     _upper: RegularSurface | None = None  # upper surf, resampled to cube map resolution
     _lower: RegularSurface | None = None  # lower surf, resampled to cube map resolution
     _min_thickness_mask: RegularSurface | None = None  # mask for min. thickness trunc.
+    _mask_map_by_traceidcode: RegularSurface | None = None  # mask for traceidcode 2
 
     _result_attr_maps: dict = field(default_factory=dict)  # holds the resulting maps
 
@@ -94,6 +95,7 @@ class CubeAttrs:
             else self.lower_surface
         )
 
+        # the template surface is the topology that defines the resulting attribute maps
         self._template_surface = (
             upper
             if isinstance(self.upper_surface, (float, int))
@@ -184,7 +186,7 @@ class CubeAttrs:
         from xtgeo import Cube  # avoid circular import by having this here
 
         cubev = self.cube.values.copy()  # copy, so we don't change the input instance
-        cubev[self.cube.traceidcodes == 2] = np.nan  # set dead traces to nan
+        cubev[self.cube.traceidcodes == 2] = 0.0  # set traceidcode 2 to zero
 
         # Create a boolean mask based on the threshold
         mask = self._depth_array < self._outside_depth
@@ -311,13 +313,20 @@ class CubeAttrs:
         attr_map = self._upper.copy()
         attr_map.values = np.ma.masked_invalid(values)
 
+        # apply mask for the cube's dead traces (traceidcode 2)
+        attr_map.values = np.ma.masked_where(
+            self.cube.traceidcodes == 2, attr_map.values
+        )
+
         # now resample to the original input map
         attr_map_resampled = self._template_surface.copy()
         attr_map_resampled.resample(attr_map)
 
-        attr_map_resampled.values = np.ma.masked_where(
-            self.upper_surface.values.mask, attr_map_resampled.values
-        )
+        # Use template_surface consistently for masking (it's already set correctly)
+        if hasattr(self._template_surface.values, "mask"):
+            attr_map_resampled.values = np.ma.masked_where(
+                self._template_surface.values.mask, attr_map_resampled.values
+            )
 
         self._result_attr_maps[attr_name] = attr_map_resampled
 

xtgeo/grid3d/_grdecl_format.py

@@ -4,6 +4,8 @@ import warnings
 from contextlib import contextmanager
 from typing import TYPE_CHECKING
 
+import numpy as np
+
 from xtgeo.common import null_logger
 
 if TYPE_CHECKING:
@@ -15,6 +17,47 @@ if TYPE_CHECKING:
 logger = null_logger(__name__)
 
 
+def run_length_encoding(arr: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Perform run-length encoding on a 1D NumPy array.
+
+    Run-length encoding is a data compression technique that represents
+    consecutive  repeated values as a single value and its count.
+
+    Args:
+        arr (np.ndarray): A 1D NumPy array to be encoded.
+
+    Returns:
+        tuple[np.ndarray, np.ndarray]: A tuple containing two 1D NumPy arrays:
+            - counts (np.ndarray): An array of counts representing the number
+              of consecutive occurrences of each unique value.
+            - values (np.ndarray): An array of the unique values corresponding to
+              the counts.
+
+    Examples:
+        >>> import numpy as np
+        >>> arr = np.array([1, 1, 2, 2, 2, 3, 3, 1, 1, 1])
+        >>> counts, values = run_length_encoding(arr)
+        >>> print(counts)
+        [2 3 2 3]
+        >>> print(values)
+        [1 2 3 1]
+
+        >>> arr = np.array([5, 5, 5, 5, 5])
+        >>> counts, values = run_length_encoding(arr)
+        >>> print(counts)
+        [5]
+        >>> print(values)
+        [5]
+
+    """
+    change_indices = np.where(~np.isclose(arr[:-1], arr[1:]))[0] + 1
+    counts = np.diff(np.concatenate(([0], change_indices, [len(arr)])))
+    values = arr[np.concatenate(([0], change_indices))]
+
+    return counts, values
+
+
 def split_line(line: str) -> Generator[str, None, None]:
     """
     split a keyword line inside a grdecl file. This splits the values of a

xtgeo/grid3d/_grdecl_grid.py

@@ -41,7 +41,7 @@ from ._ecl_grid import (
     MapAxes,
     Units,
 )
-from ._grdecl_format import IGNORE_ALL, open_grdecl
+from ._grdecl_format import IGNORE_ALL, open_grdecl, run_length_encoding
 
 
 @dataclass
@@ -311,20 +311,22 @@ class GrdeclGrid(EclGrid):
                 results[kw.lower()] = factory(values)
         return cls(**results)
 
-    def to_file(self, filename, fileformat="grdecl"):
+    def to_file(self, filename, fileformat="grdecl", rle: bool = False):
         """
         write the grdeclgrid to a file.
         :param filename: path to file to write.
         :param fileformat: Either "grdecl" or "bgrdecl" to
             indicate binary or ascii format.
+        :param rle: Boolean flag indicating whether to use Run-Length Encoding (RLE)
+                    compression when writing the file (only for grdecl).
         """
         if fileformat == "grdecl":
-            return self._to_grdecl_file(filename)
+            return self._to_grdecl_file(filename, rle)
         if fileformat == "bgrdecl":
             return self._to_bgrdecl_file(filename)
         raise ValueError(b"Unknown grdecl file format {fileformat}")
 
-    def _to_grdecl_file(self, filename):
+    def _to_grdecl_file(self, filename, rle):
         with open(filename, "w") as filestream:
             keywords = [
                 ("SPECGRID", self.specgrid.to_grdecl()),
@@ -340,14 +342,24 @@ class GrdeclGrid(EclGrid):
                 if values is None:
                     continue
                 filestream.write(f"{kw}\n")
-                numcolumns = 0
-                for value in values:
-                    numcolumns += 1
-                    filestream.write(f" {value}")
-
-                    if numcolumns >= 6:  # 6 should ensure < 128 character width total
-                        filestream.write("\n")
-                        numcolumns = 0
+                if rle and (kw == "ACTNUM"):
+                    counts, unique_values = run_length_encoding(values)
+                    for i, (count, unique_value) in enumerate(
+                        zip(counts, unique_values)
+                    ):
+                        filestream.write(
+                            f" {count}*{unique_value}"
+                            if count > 1
+                            else f" {unique_value}"
+                        )
+                        if i % 6 == 5:
+                            filestream.write("\n")
+                else:
+                    for i, value in enumerate(values):
+                        filestream.write(f" {value}")
+
+                        if i % 6 == 5:  # 6 should ensure < 128 character width total
+                            filestream.write("\n")
 
                 filestream.write("\n /\n")
 

xtgeo/grid3d/_grid_etc1.py

@@ -309,23 +309,34 @@ def get_heights_above_ffl(
     grid: Grid,
     ffl: GridProperty,
     option: Literal[
-        "cell_center_above_ffl", "cell_corners_above_ffl"
+        "cell_center_above_ffl",
+        "cell_corners_above_ffl",
+        "truncated_cell_corners_above_ffl",
     ] = "cell_center_above_ffl",
 ) -> tuple[GridProperty, GridProperty, GridProperty]:
     """Compute delta heights for cell top, bottom and midpoints above a given level."""
 
-    valid_options = ("cell_center_above_ffl", "cell_corners_above_ffl")
+    valid_options = (
+        "cell_center_above_ffl",
+        "cell_corners_above_ffl",
+        "truncated_cell_corners_above_ffl",
+    )
     if option not in valid_options:
         raise ValueError(
             f"The option key <{option}> is invalid, must be one of {valid_options}"
         )
+    if option == "cell_center_above_ffl":
+        option_flag = _internal.grid3d.HeightAboveFFLOption.CellCenter
+    elif option == "cell_corners_above_ffl":
+        option_flag = _internal.grid3d.HeightAboveFFLOption.CellCorners
+    else:
+        option_flag = _internal.grid3d.HeightAboveFFLOption.TruncatedCellCorners
 
     grid._set_xtgformat2()
 
     grid_cpp = grid._get_grid_cpp()
     htop_arr, hbot_arr, hmid_arr = grid_cpp.get_height_above_ffl(
-        ffl.values.ravel(),
-        1 if option == "cell_center_above_ffl" else 2,
+        ffl.values.ravel(), option_flag
     )
 
     htop = GridProperty(
@@ -1053,13 +1064,18 @@ def inactivate_inside(
         raise RuntimeError("Problems with one or more polygons. Not closed?")
 
 
-def collapse_inactive_cells(self: Grid) -> None:
+def collapse_inactive_cells(self: Grid, internal: bool = True) -> None:
     """Collapse inactive cells."""
-    self._set_xtgformat1()
+    logger.debug("Collapsing inactive cells...")
+    self._set_xtgformat2()
 
-    _cxtgeo.grd3d_collapse_inact(
-        self.ncol, self.nrow, self.nlay, self._zcornsv, self._actnumsv
-    )
+    grid_cpp = _internal.grid3d.Grid(self)
+    new_zcornsv = grid_cpp.collapse_inactive_cells(collapse_internal=internal)
+
+    if new_zcornsv is not None:
+        self._zcornsv = new_zcornsv
+
+    logger.debug("Collapsing inactive cells done")
 
 
 def copy(self: Grid) -> Grid:

xtgeo/grid3d/_grid_export.py

@@ -49,10 +49,11 @@ def export_roff(
         )
 
 
-def export_grdecl(grid: Grid, gfile: FileLike, mode: int) -> None:
-    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0)."""
+def export_grdecl(grid: Grid, gfile: FileLike, mode: int, rle: bool = False) -> None:
+    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0).
+    Optionally for ASCII GRDECL, run-length encoding RLE can be applied"""
     fileformat = "grdecl" if mode == 1 else "bgrdecl"
-    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat)
+    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat, rle=rle)
 
 
 def export_egrid(grid: Grid, gfile: FileLike) -> None:

xtgeo/grid3d/_gridprop_export.py

@@ -17,6 +17,7 @@ from xtgeo.common.exceptions import InvalidFileFormatError
 from xtgeo.common.log import null_logger
 from xtgeo.io._file import FileFormat, FileWrapper
 
+from ._grdecl_format import run_length_encoding
 from ._roff_parameter import RoffParameter
 
 if TYPE_CHECKING:
@@ -37,6 +38,7 @@ def to_file(
     append: bool = False,
     dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
     fmt: str | None = None,
+    rle: bool = False,
 ) -> None:
     """Export the grid property to file."""
     logger.debug("Export property to file %s as %s", pfile, fformat)
@@ -62,6 +64,7 @@ def to_file(
             append=append,
             binary=binary,
             fmt=fmt,
+            rle=rle,
         )
     elif fformat == "xtgcpprop":
         _export_xtgcpprop(gridprop, xtg_file.name)
@@ -104,6 +107,7 @@ def _export_grdecl(
     append: bool = False,
     binary: bool = False,
     fmt: str | None = None,
+    rle: bool = False,
 ) -> None:
     """Export ascii or binary GRDECL"""
     vals: npt.NDArray = gridprop.values.ravel(order="F")
@@ -132,18 +136,36 @@ def _export_grdecl(
         else:
             # Always the case when not binary
             assert isinstance(fout, io.TextIOWrapper)
-            fout.write(name)
-            fout.write("\n")
-            for i, v in enumerate(vals):
-                fout.write(" ")
-                if fmt:
-                    fout.write(fmt % v)
-                elif gridprop.isdiscrete:
-                    fout.write(str(v))
-                else:
-                    fout.write(f"{v:3e}")
-                if i % 6 == 5:
-                    fout.write("\n")
+            fout.write(f"{name}\n")
+            if rle:
+                counts, unique_values = run_length_encoding(vals)
+                for i, (count, unique_value) in enumerate(zip(counts, unique_values)):
+                    fout.write(" ")
+                    if fmt:
+                        formatted_value = fmt % unique_value
+                    elif gridprop.isdiscrete:
+                        formatted_value = str(unique_value)
+                    else:
+                        formatted_value = f"{unique_value:3e}"
+                    if count > 1:
+                        # Try to preserve the alignment
+                        text_width = len(formatted_value)
+                        new_text = f"{count}*{formatted_value.lstrip()}"
+                        formatted_value = " " * (text_width - len(new_text)) + new_text
+                    fout.write(formatted_value)
+                    if i % 6 == 5:
+                        fout.write("\n")
+            else:
+                for i, v in enumerate(vals):
+                    fout.write(" ")
+                    if fmt:
+                        fout.write(fmt % v)
+                    elif gridprop.isdiscrete:
+                        fout.write(str(v))
+                    else:
+                        fout.write(f"{v:3e}")
+                    if i % 6 == 5:
+                        fout.write("\n")
             fout.write(" /\n")
 
 

xtgeo/grid3d/_gridprop_op1.py

@@ -25,6 +25,77 @@ _ValueList = List[List[_CoordOrValue]]
 XYValueLists = Tuple[_XYCoordList, _ValueList]
 
 
+def _validate_cast_range(values: np.ndarray, target_dtype: np.dtype) -> None:
+    """Validate that values fit in target dtype range."""
+    if np.issubdtype(target_dtype, np.integer):
+        info = np.iinfo(target_dtype)
+        min_val, max_val = info.min, info.max
+
+        # Check actual value ranges
+        actual_min = np.nanmin(values)
+        actual_max = np.nanmax(values)
+
+        if actual_min < min_val or actual_max > max_val:
+            raise ValueError(
+                f"Values [{actual_min}, {actual_max}] exceed {target_dtype} "
+                f"range [{min_val}, {max_val}]"
+            )
+    elif np.issubdtype(target_dtype, np.floating):
+        info = np.finfo(target_dtype)
+        # Check for overflow/underflow
+        if np.any(np.abs(values[np.isfinite(values)]) > info.max):
+            raise ValueError(f"Values too large for {target_dtype}")
+
+
+def discrete_to_continuous(self: GridProperty) -> None:
+    """Convert from discrete to continuous values."""
+    if not self.isdiscrete:
+        logger.debug("No need to convert, already continuous")
+        return
+
+    logger.debug("Converting to continuous ...")
+    val = self._values.copy()
+    val = val.astype(np.float64)
+    self._values = val
+    self._isdiscrete = False
+    self._codes = {}
+    self.roxar_dtype = np.float32
+
+
+def continuous_to_discrete(self) -> None:
+    """Convert from continuous to discrete values."""
+    if self.isdiscrete:
+        logger.debug("No need to convert, already discrete")
+        return
+
+    logger.debug("Converting to discrete ...")
+    val = self._values.copy()
+
+    # Validate finite values only
+    finite_vals = (
+        val[np.isfinite(val)]
+        if not isinstance(val, np.ma.MaskedArray)
+        else val.compressed()
+    )
+    if len(finite_vals) > 0:
+        _validate_cast_range(finite_vals, np.int32)
+
+    # Round and cast, suppressing the NaN warning
+    val = np.round(val)
+    with np.errstate(invalid="ignore"):
+        val = val.astype(np.int32)
+
+    self._values = val
+    self._isdiscrete = True
+
+    self._codes = {
+        v: str(v)
+        for v in np.ma.unique(val)
+        if np.isfinite(v) and not isinstance(v, np.ma.core.MaskedConstant)
+    }
+    self.roxar_dtype = np.uint16
+
+
 def get_xy_value_lists(
     self: GridProperty,
     grid: Optional[Grid | GridProperty] = None,
@@ -134,12 +205,6 @@ def operation_polygons(
 
     gl.update_values_from_carray(proxy, cvals, np.float64, delete=True)
 
-    proxyv = proxy.values.astype(np.int8)
-
-    proxytarget = 1
-    if not inside:
-        proxytarget = 0
-
     if opname == "add":
         tmp = self.values.copy() + value
     elif opname == "sub":
@@ -170,8 +235,9 @@ def operation_polygons(
     # convert tmp back to correct dtype
     tmp = tmp.astype(dtype)
 
-    self.values[proxyv == proxytarget] = tmp[proxyv == proxytarget]
-    del tmp
+    mask = proxy.values == 1 if inside else proxy.values == 0
+
+    self.values[mask] = tmp[mask]
 
 
 def refine(

xtgeo/grid3d/_gridprop_roxapi.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Literal
+from warnings import warn
 
 import numpy as np
 from numpy import ma
@@ -135,6 +136,51 @@ def export_prop_roxapi(
     rox.safe_close()
 
 
+def _validate_dtype_in_roxar(
+    pval: np.ndarray, original_dtype: Any, dtype: Any, allow_unsafe_casting: bool = True
+) -> None:
+    """Local routine that check the range in xtgeo's parameter vs Roxar dtype"""
+    message = ""
+
+    if dtype != original_dtype:
+        message += (
+            f"Existing RMS icon has data type {original_dtype} while "
+            f"GridProperty has RMS data type {dtype}. This may cause issues in data "
+            "content while saving to RMS."
+        )
+
+    try:
+        if np.issubdtype(dtype, np.integer):
+            # Integer type
+            min_val, max_val = np.iinfo(dtype).min, np.iinfo(dtype).max
+        elif np.issubdtype(dtype, np.floating):
+            # Float type
+            min_val, max_val = np.finfo(dtype).min, np.finfo(dtype).max
+        else:
+            # Unknown type
+            raise RuntimeError("Probable bug, values array not integer or float")
+
+        if pval.min() < min_val or pval.max() > max_val:
+            message += (
+                f"Values outside {dtype} range [{min_val}, {max_val}] found. "
+                f"Range in xtgeo values are [{pval.min()}, {pval.max()}]"
+            )
+
+    except (ValueError, OverflowError):
+        # Handle edge cases gracefully
+        message += f"Could not validate range for dtype {dtype}. "
+
+    if message and allow_unsafe_casting:
+        message += (
+            "\nUnsafe casting is allowed; this means that original values may "
+            "be truncated which may give unpredictable results and/or mess "
+            "up code names and values settings."
+        )
+
+    if message:
+        warn(message, UserWarning)
+
+
 def _store_in_roxar(
     self: GridProperty,
     pname: str,
@@ -147,50 +193,60 @@ def _store_in_roxar(
 
     logger.info("Store in RMS...")
 
-    val3d = self.values.copy()
-
-    cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
-
-    ijk = indexer.get_indices(cellno)
+    roxtype: Any = roxar  # needed for mypy
+    roxar_property_type = (
+        roxtype.GridPropertyType.discrete
+        if self.isdiscrete
+        else roxtype.GridPropertyType.continuous
+    )
 
-    iind = ijk[:, 0]
-    jind = ijk[:, 1]
-    kind = ijk[:, 2]
+    val3d = self.values.copy()
 
     dtype = self._roxar_dtype
     logger.info("DTYPE is %s for %s", dtype, pname)
 
-    # casting will secure correct types
     if dtype not in VALID_ROXAR_DTYPES:
         raise TypeError(
             f"Roxar dtype is not valid: {dtype} must be in {VALID_ROXAR_DTYPES}"
         )
 
-    pvalues = roxgrid.get_grid(realisation=realisation).generate_values(data_type=dtype)
-
-    roxtype: Any = roxar  # needed for mypy
-    roxar_property_type = (
-        roxtype.GridPropertyType.discrete
-        if self.isdiscrete
-        else roxtype.GridPropertyType.continuous
-    )
-
-    pvalues[cellno] = val3d[iind, jind, kind]
-
     properties = roxgrid.properties
-
+    original_dtype = dtype
     if pname not in properties:
         rprop = properties.create(
             pname, property_type=roxar_property_type, data_type=dtype
         )
     else:
         rprop = properties[pname]
-        dtype = rprop.data_type
+        original_dtype = rprop.data_type
+
+    _validate_dtype_in_roxar(val3d, original_dtype, dtype, casting == "unsafe")
 
-    rprop.set_values(pvalues.astype(dtype, casting=casting), realisation=realisation)
+    dtype = original_dtype
+    val3d = val3d.astype(dtype, casting=casting)
 
-    if self.isdiscrete:
-        rprop.code_names = _rox_compatible_codes(self.codes)
+    cellno = indexer.get_cell_numbers_in_range((0, 0, 0), indexer.dimensions)
+
+    ijk = indexer.get_indices(cellno)
+
+    iind = ijk[:, 0]
+    jind = ijk[:, 1]
+    kind = ijk[:, 2]
+
+    pvalues = roxgrid.get_grid(realisation=realisation).generate_values(data_type=dtype)
+
+    pvalues[cellno] = val3d[iind, jind, kind]
+    rprop.set_values(pvalues, realisation=realisation)
+
+    if self.isdiscrete and "float" not in str(original_dtype):
+        try:
+            rprop.code_names = _rox_compatible_codes(self.codes)
+        except ValueError as verr:
+            message = (
+                f"Trying to set codes in Roxar: {self.codes} for type "
+                f"{self._roxar_dtype}. {str(verr)} Consider editing the codes!"
+            )
+            raise ValueError(message)
 
 
 def _fix_codes(

xtgeo/grid3d/grid.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Any, Literal, NoReturn
+from typing import TYPE_CHECKING, Any, Literal
 
 import numpy as np
 import numpy.ma as ma
@@ -994,13 +994,16 @@ class Grid(_Grid3D):
     # Create/import/export
     # ==================================================================================
 
-    def to_file(self, gfile: FileLike, fformat: str = "roff") -> None:
+    def to_file(
+        self, gfile: FileLike, fformat: str = "roff", rle: bool = False
+    ) -> None:
         """Export grid geometry to file, various vendor formats.
 
         Args:
             gfile (str): Name of output file
             fformat (str): File format; roff/roff_binary/roff_ascii/
                 grdecl/bgrdecl/egrid.
+            rle (bool): Use run-length encoding (only for grdecl file)
 
         Raises:
             OSError: Directory does not exist
@@ -1018,7 +1021,7 @@ class Grid(_Grid3D):
         elif fformat in FileFormat.ROFF_ASCII.value:
             _grid_export.export_roff(self, _gfile.name, "ascii")
         elif fformat in FileFormat.GRDECL.value:
-            _grid_export.export_grdecl(self, _gfile.name, 1)
+            _grid_export.export_grdecl(self, _gfile.name, 1, rle)
         elif fformat in FileFormat.BGRDECL.value:
             _grid_export.export_grdecl(self, _gfile.name, 0)
         elif fformat in FileFormat.EGRID.value:
@@ -1577,9 +1580,30 @@ class Grid(_Grid3D):
 
         return self.get_subgrids()
 
-    def get_zoneprop_from_subgrids(self) -> NoReturn:
-        """Make a XTGeo GridProperty instance for a Zone property subgrid index."""
-        raise NotImplementedError("Not yet; todo")
+    def get_zoneprop_from_subgrids(self) -> xtgeo.GridProperty | None:
+        """
+        Create a discrete GridProperty encoding subgrid indices as zone values.
+
+        Returns:
+            A GridProperty where each layer belonging to a subgrid is assigned a unique
+            integer zone index (starting from 1). The property codes map these indices
+            to subgrid names. Returns None if no subgrids are defined.
+        """
+        if not self.subgrids:
+            return None
+
+        zoneprop = xtgeo.GridProperty(
+            ncol=self.ncol,
+            nrow=self.nrow,
+            nlay=self.nlay,
+            name="Zone",
+            discrete=True,
+            values=0,
+        )
+        for i, (name, layers) in enumerate(self.subgrids.items()):
+            zoneprop.codes[i + 1] = name
+            zoneprop.values[:, :, min(layers) - 1 : max(layers)] = i + 1
+        return zoneprop
 
     def get_boundary_polygons(
         self: Grid,
@@ -1966,12 +1990,14 @@ class Grid(_Grid3D):
             ffl: Free fluid level e.g. FWL (or level whatever is required; a level from
                 which cells above will be shown as delta heights (positive), while
                 cells below will have 0.0 values.
-            option: How to compute values, as either "cell_center_above_ffl" or
-                "cell_corners_above_ffl". The first one looks at cell Z centerlines, and
-                compute the top, the bottom and the midpoint. The second will look at
-                cell corners, using the uppermost corner for top, and the lowermost
-                corner for bottom. In both cases, values are modified if cell is
-                intersected with the provided ffl.
+            option: How to compute values, as either "cell_center_above_ffl",
+                "cell_corners_above_ffl" or "truncated_cell_corners_above_ffl".
+                The first one looks at cell Z centerlines, and compute the top,
+                the bottom and the midpoint. The second will look at cell corners,
+                using the uppermost corner for top, and the lowermost corner for bottom.
+                The third will truncate all cell corners above ffl and compute cell Z
+                centerlines. In all cases, values are modified if cell is intersected
+                with the provided ffl.
 
         Returns:
             (htop, hbot, hmid) delta heights, as xtgeo GridProperty objects
@@ -2295,7 +2321,7 @@ class Grid(_Grid3D):
         * maxangle_topbase_proj (degrees) max angle projected (bird view)
         * minangle_sides (degress) minimum angle, all side surfaces
         * maxangle_sides (degress) maximum angle, all side surfaces
-        * collapsed (int) Integer, 1 of one or more corners are collpased in Z
+        * collapsed (int) Integer, 1 of one or more corners are collapsed in Z
         * faulted (int) Integer, 1 if cell is faulted (one or more neighbours offset)
         * negative_thickness (int) Integer, 1 if cell has negative thickness
         * concave_proj (int) 1 if cell is concave seen from projected bird view
@@ -2332,7 +2358,7 @@ class Grid(_Grid3D):
         inside: bool = True,
         force_close: bool = False,
     ) -> None:
-        """Inacativate grid inside a polygon.
+        """Inactivate grid inside a polygon.
 
         The Polygons instance may consist of several polygons. If a polygon
         is open, then the flag force_close will close any that are not open
@@ -2359,14 +2385,30 @@ class Grid(_Grid3D):
         layer_range: tuple[int, int] | None = None,
         force_close: bool = False,
     ) -> None:
-        """Inacativate grid outside a polygon."""
+        """Inactivate grid outside a polygon."""
         self.inactivate_inside(
             poly, layer_range=layer_range, inside=False, force_close=force_close
         )
 
-    def collapse_inactive_cells(self) -> None:
-        """Collapse inactive layers where, for I J with other active cells."""
-        _grid_etc1.collapse_inactive_cells(self)
+    def collapse_inactive_cells(self, internal: bool = True) -> None:
+        """Collapse inactive layers per I J column (~vertically).
+
+        Seen by I,J column, the inactive cells are collapsed to the first active cell in
+        the column. First transversed from top, then from bottom. If no active cells in
+        the column, the (invisible) Z coordinates are averaged to one common location.
+
+        If `internal` is True (default), then also internal inactive cells (i.e.
+        inactive "hole" surrounded by active cells) are collapsed. In this case the Z
+        coordinates of the adjacent active cells are moved to fill the gap.
+
+        The current grid instance will be updated.
+
+        Args:
+            internal: If True (default), then the internal collapse is also done.
+
+        .. versionchanged:: 4.11 Added ``internal option``, algorithm is improved
+        """
+        _grid_etc1.collapse_inactive_cells(self, internal=internal)
 
     def crop(
         self,

xtgeo/grid3d/grid_property.py

@@ -773,6 +773,7 @@ class GridProperty(_Grid3D):
         append: bool = False,
         dtype: type[np.float32] | type[np.float64] | type[np.int32] | None = None,
         fmt: str | None = None,
+        rle: bool = False,
     ) -> None:
         """
         Export the grid property to file.
@@ -791,6 +792,7 @@ class GridProperty(_Grid3D):
                 Eclipse formats.
             fmt: Format for ascii grdecl format. Default is None. If specified,
                 the user is responsible for a valid format specifier, e.g. "%8.4f".
+            rle: Use run length encoding, only for grdecl format.
 
         Example::
 
@@ -815,6 +817,7 @@ class GridProperty(_Grid3D):
             append=append,
             dtype=dtype,
             fmt=fmt,
+            rle=rle,
         )
 
     @classmethod
@@ -1222,36 +1225,11 @@ class GridProperty(_Grid3D):
 
     def discrete_to_continuous(self) -> None:
         """Convert from discrete to continuous values."""
-        if not self.isdiscrete:
-            logger.debug("No need to convert, already continuous")
-            return
-
-        logger.debug("Converting to continuous ...")
-        val = self._values.copy()
-        val = val.astype("float64")
-        self._values = val
-        self._isdiscrete = False
-        self._codes = {}
-        self.roxar_dtype = np.float32
+        _gridprop_op1.discrete_to_continuous(self)
 
     def continuous_to_discrete(self) -> None:
         """Convert from continuous to discrete values."""
-        if self.isdiscrete:
-            logger.debug("No need to convert, already discrete")
-            return
-
-        logger.debug("Converting to discrete ...")
-        val = self._values.copy()
-        val = val.astype(np.int32)
-        self._values = val
-        self._isdiscrete = True
-
-        # make the code list
-        uniq = np.unique(val).tolist()
-        codes = dict(zip(uniq, uniq))
-        codes = {k: str(v) for k, v in codes.items()}  # val as strings
-        self._codes = codes
-        self.roxar_dtype = np.uint16
+        _gridprop_op1.continuous_to_discrete(self)
 
     # ==================================================================================
     # Operations restricted to inside/outside polygons

xtgeo/metadata/metadata.py

@@ -10,10 +10,17 @@ The metadata works through the various datatypes in XTGeo. For example::
 
 """
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 import xtgeo
 from xtgeo.common.constants import UNDEF
 from xtgeo.common.log import null_logger
 
+if TYPE_CHECKING:
+    from datetime import datetime
+
 logger = null_logger(__name__)
 
 
@@ -50,10 +57,10 @@ class _OptionalMetaData:
         self._name = "A Longer Descriptive Name e.g. from SMDA"
         self._shortname = "TheShortName"
         self._datatype = None
-        self._md5sum = None
+        self._md5sum: str | None = None
         self._description = "Some description"
         self._crs = None
-        self._datetime = None
+        self._datetime: datetime | None = None
         self._deltadatetime = None
         self._visuals = {"colortable": "rainbow", "lower": None, "upper": None}
         self._domain = "depth"
@@ -68,29 +75,29 @@ class _OptionalMetaData:
         self._source = "unknown"
 
     @property
-    def name(self):
+    def name(self) -> str:
         return self._name
 
     @name.setter
-    def name(self, newname):
+    def name(self, newname: str) -> None:
         # TODO: validation
         self._name = newname
 
     @property
-    def datetime(self):
+    def datetime(self) -> datetime | None:
         return self._datetime
 
     @datetime.setter
-    def datetime(self, newdate):
+    def datetime(self, newdate: datetime) -> None:
         # TODO: validation
         self._datetime = newdate
 
     @property
-    def shortname(self):
+    def shortname(self) -> str:
         return self._shortname
 
     @shortname.setter
-    def shortname(self, newname):
+    def shortname(self, newname: str) -> None:
         if not isinstance(newname, str):
             raise ValueError("The shortname must be a string.")
         if len(newname) >= 32:
@@ -99,11 +106,11 @@ class _OptionalMetaData:
         self._shortname = newname
 
     @property
-    def description(self):
+    def description(self) -> str:
         return self._description
 
     @description.setter
-    def description(self, newstr):
+    def description(self, newstr: str) -> None:
         if not isinstance(newstr, str):
             raise ValueError("The description must be a string.")
         if len(newstr) >= 64:
@@ -115,7 +122,7 @@ class _OptionalMetaData:
         self._description = newstr
 
     @property
-    def md5sum(self):
+    def md5sum(self) -> str | None:
         """Set or get the md5 checksum of file content.
 
         See generate_hash() method in e.g. RegularSurface.
@@ -123,11 +130,11 @@ class _OptionalMetaData:
         return self._md5sum
 
     @md5sum.setter
-    def md5sum(self, newhash):
+    def md5sum(self, newhash: str) -> None:
         # TODO: validation
         self._md5sum = newhash
 
-    def get_meta(self):
+    def get_meta(self) -> dict[str, Any]:
         """Return metadata as an dict."""
         meta = {}
         for key in self.__slots__:

{xtgeo-4.10.1.dist-info → xtgeo-4.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xtgeo
-Version: 4.10.1
+Version: 4.12.0
 Summary: XTGeo is a Python library for 3D grids, surfaces, wells, etc
 Keywords: grids,surfaces,wells,cubes
 Author-Email: Equinor <fg_fmu-atlas@equinor.com>
@@ -14,7 +14,6 @@ Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -27,7 +26,7 @@ Project-URL: Homepage, https://github.com/equinor/xtgeo
 Project-URL: Repository, https://github.com/equinor/xtgeo
 Project-URL: Issues, https://github.com/equinor/xtgeo/issues
 Project-URL: Documentation, https://xtgeo.readthedocs.io
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: deprecation
 Requires-Dist: h5py>=3
 Requires-Dist: hdf5plugin>=2.3
@@ -92,7 +91,7 @@ Detailed documentation for [XTGeo at Read _the_ Docs](https://xtgeo.readthedocs.
 
 ## Feature summary
 
--   Python 3.9+ support
+-   Python 3.10+ support
 -   Focus on high speed, using numpy and pandas with C backend
 -   Regular surfaces, i.e. 2D maps with regular sampling and rotation
 -   3D grids (corner-point), supporting several formats such as

{xtgeo-4.10.1.dist-info → xtgeo-4.12.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 cxtgeo.py,sha256=TdHva0vqjD5B_9jA6kxvev9i2kvZ4Oftc1bQoLdFNXQ,33972
 cxtgeoPYTHON_wrap.c,sha256=E76gd7QM28i3EYkuQEA1V_-3cxzXxsi_b151ZcEszxk,655525
 xtgeo/__init__.py,sha256=edNCOXuPS5qjutDGX5-2Pz0T2Lpx1GoeG3IoeXUdBw8,5834
-xtgeo/_cxtgeo.cp312-win_amd64.pyd,sha256=hieMCet9KYtkyhytQ_1HLnOdssLuLrZgm7N88PHbNO4,728064
-xtgeo/_internal.cp312-win_amd64.pyd,sha256=qnDPNRC13gwihiOaQL2qHjAJsCTFirfOknwVgPHoAIo,910336
+xtgeo/_cxtgeo.cp312-win_amd64.pyd,sha256=VpIuaVWOpWE7QIvE6Zqa58i2iDv7fJ4dYmz3OwavT7I,720896
+xtgeo/_internal.cp312-win_amd64.pyd,sha256=SMvHNjTgIYsZgRWo9-DlE1JCuLZVUlVzDP7blcCxjUk,985600
 xtgeo/common/__init__.py,sha256=6R_OizhLnAoJUmUoQtGqgNvGcn1HWc4udc6YvRRlxWQ,480
 xtgeo/common/_angles.py,sha256=fAX5FzgqIjjIDe9_C7gy6zPjdaSQuzMb8Z2XdKSx-6Y,851
 xtgeo/common/_xyz_enum.py,sha256=gb1PVOWMTRb4YGDq9Q0YVVkKqMyI_xBg1vUBvOLXlfs,1095
@@ -12,14 +12,14 @@ xtgeo/common/exceptions.py,sha256=OZyU9C8cS4NhCnjQyREfuoVy9mdvGCiccd4nC9yn_N4,12
 xtgeo/common/log.py,sha256=8-wTrZd87UNr_ZEb_lZvR1khUeKmIO_UECMpV_Q_btM,2835
 xtgeo/common/sys.py,sha256=lvvmS4D7qaAVVg5UueNSt44WeEgpZcmyINEGKLHXctM,5144
 xtgeo/common/types.py,sha256=LanIGZh0HU2XXfJelZA-FC__J6fLB1DzuN7jj7hNSgU,362
-xtgeo/common/version.py,sha256=webkQYCLapKyXq4N-wy_1-S59jreweESFu1CwTt_iwA,534
+xtgeo/common/version.py,sha256=TGPzC91qCIpsmAjdh_1loT2Gs_vjWi5JhetfyITnpsU,748
 xtgeo/common/xtgeo_dialog.py,sha256=XX445byFvdRjT2Eg9Mgd3ChRQ9d1Mj5MEdsBRYBSo8A,17733
 xtgeo/cube/__init__.py,sha256=5_F9Cefu4081jIwDqsyJGKTlrVLe1UfwI8wQXVRYPDM,169
 xtgeo/cube/_cube_export.py,sha256=YcU_0c_kFyh8T_ytY8XRR9Bmt8KK3J1taMLzo_w_m4c,6659
 xtgeo/cube/_cube_import.py,sha256=F6uWEXWxX0a4Px6HVa0pRCPNcfr36bMe_559CSf4h9c,17314
 xtgeo/cube/_cube_roxapi.py,sha256=UvU4yr1b1ZTyYxBIj7_ei2aub_VqAdP9S_6znpzDJ14,5101
 xtgeo/cube/_cube_utils.py,sha256=Mx79j29QLBJQ8wlwAfVgb-xN0ud7ilRIh6jOx7HMs2o,7727
-xtgeo/cube/_cube_window_attributes.py,sha256=CN2nweAwnREtE-5pANWTwCDG0KLH9-SL2K4zwVCqs0U,12435
+xtgeo/cube/_cube_window_attributes.py,sha256=NAgm2WCjpiFx5eLUM5G0HqUSf0SKaVb6hVOXMD7x3zs,12956
 xtgeo/cube/cube1.py,sha256=QKqKIGH814zehx-avRuett996cx8lI-2bYyjuqaCmkw,35864
 xtgeo/grid3d/__init__.py,sha256=yctcaBS-PW_s3hCd7xq-XZZi514R_fgcpIrMnETZ87w,347
 xtgeo/grid3d/_ecl_grid.py,sha256=Oqe0_4ErUZkM-le4EnM6hMqXGMpMZyrr9-W9Xa7ZN1A,26679
@@ -28,14 +28,14 @@ xtgeo/grid3d/_ecl_logi_head.py,sha256=pioEgigpnLjyDWq07Msp82xS15GCxrBZfSpEd2klEu
 xtgeo/grid3d/_ecl_output_file.py,sha256=8IPXV-WMkh37VH78XibmMuVK9zBkmimqwc-uqy_1VCQ,2095
 xtgeo/grid3d/_egrid.py,sha256=S-X1B8vmO_Zmj8dJZuEdVUDDu3noXhTGgg6udB2hHVg,34839
 xtgeo/grid3d/_find_gridprop_in_eclrun.py,sha256=JsCBFvUsTBcCD6tFdn4ON8zOLGFT6PyhyDr8SL9fyJs,22059
-xtgeo/grid3d/_grdecl_format.py,sha256=QvNmixzdWIztDfRiqfX_j4qKiDENgDg25hxxCqtBBQM,9041
-xtgeo/grid3d/_grdecl_grid.py,sha256=mvkx-bKcdCSVDml6frsuWjTiIFulcqlARuNGiukO17A,13281
+xtgeo/grid3d/_grdecl_format.py,sha256=1AwSTrLNx4XCthHXNDH4cmNOGC2QWoWfhBM1jMxN91A,10447
+xtgeo/grid3d/_grdecl_grid.py,sha256=f7hzGg3M9Rd7DVnqR_8D0WGBUSWlDFfnIBmz_80kVTk,14002
 xtgeo/grid3d/_grid3d.py,sha256=rTqfhwK4dNX1A5M-xUC-9hWwfxrkX6_TVgwc79KCXCI,769
 xtgeo/grid3d/_grid3d_fence.py,sha256=yDmKwlErNCl13vV7opJjKlzlwCzwk2gSJnzIb4jGpHg,9501
 xtgeo/grid3d/_grid3d_utils.py,sha256=VBbdzah_D8yeaMU4vMQRYTFRKq95QaGqPk4oXYBWdHw,7477
 xtgeo/grid3d/_grid_boundary.py,sha256=xNumtMeOfjmwS5vzv1Nl_yZpGiDEQXk896pXzugdUVs,2384
-xtgeo/grid3d/_grid_etc1.py,sha256=fhjSSt1QDbXBX4FadWkufH7Q4jOquIbIaBNWC3yUI7Q,44538
-xtgeo/grid3d/_grid_export.py,sha256=krz3cL-38QYa4x7RjIH_1JyiNVMtyOpL3ZVWnfUmAWo,7391
+xtgeo/grid3d/_grid_etc1.py,sha256=V8XeVU4-1ZRDOmyDQS3FrU_SY6bZkssvMuV_boR6Uzw,45156
+xtgeo/grid3d/_grid_export.py,sha256=G36va-Kz93W-P2z8Qr-0Dq-o7Abfsd3OC8ESCAFRh2M,7492
 xtgeo/grid3d/_grid_hybrid.py,sha256=4xtZlZSzn0BY8Kl8TY6Su3QtCH16ax-Tf49ItvHaRPk,1666
 xtgeo/grid3d/_grid_import.py,sha256=Y11JDjf5tZkDth69aTtbkMfMjRbVvSnQbV3lt-jCuA8,2672
 xtgeo/grid3d/_grid_import_ecl.py,sha256=WQw0Vr7ftFdM-_Jm1KjhGJ_Ko2PPO0eLgi6lCE98VYo,3554
@@ -44,27 +44,27 @@ xtgeo/grid3d/_grid_import_xtgcpgeom.py,sha256=ZVqkf1QAvv8iDFZxV-2AhGimUjAdFcMwFm
 xtgeo/grid3d/_grid_refine.py,sha256=W5mDAJuKuCovuWRseaXfrS4Eqku0NbgqwnsuAsQOOlQ,8799
 xtgeo/grid3d/_grid_roxapi.py,sha256=ixanN3VNGQM3QeVxXLHj_hKZJSiG3cdZwHc2NdXg_ms,9199
 xtgeo/grid3d/_grid_wellzone.py,sha256=5OwMsmksC0Wza5XXfUiDHCzSLWqmV3JbSORDUFPXZho,5951
-xtgeo/grid3d/_gridprop_export.py,sha256=G9X-gF8R6cI50shG2B_d6VI0khACT-5nAx67zA_wMsU,5636
+xtgeo/grid3d/_gridprop_export.py,sha256=wKYm6UhRCrDwf74V_HuWvdlYKgET6iIm8i1fGpPgbGY,6735
 xtgeo/grid3d/_gridprop_import_eclrun.py,sha256=E8fgp5VFbJknoitP-t2JJv5LcIUuLutIDJuVXBS_ugE,5260
 xtgeo/grid3d/_gridprop_import_grdecl.py,sha256=q-RZ8wvvyxzrw8ep1yr0L997WX13d__togXMYHypGqM,4263
 xtgeo/grid3d/_gridprop_import_roff.py,sha256=vAHfXTjopeFLCVtseQdqlgkLNFfT9aW9I0nL6xiYorI,1575
 xtgeo/grid3d/_gridprop_import_xtgcpprop.py,sha256=ToajcbJL4cHo-gV1ab2rPQ0U5DxNnUfetvO1tetafNc,5027
 xtgeo/grid3d/_gridprop_lowlevel.py,sha256=1PBIn2ZMiF5Gj9u2n6xu2PFDiJ6NdrgYaL89lkq3_yo,5257
-xtgeo/grid3d/_gridprop_op1.py,sha256=EN8gsY-fl0L1x_Hiu-onf3OoEE56R1ZYsLhTghI24-0,7019
-xtgeo/grid3d/_gridprop_roxapi.py,sha256=XiPlyiDacg5UCRGkIS050IYUvP0M0I6vEYDtJB6qDhQ,7096
+xtgeo/grid3d/_gridprop_op1.py,sha256=5es5e-b14OsEnk1xt-C2iuyv0DEYYkC_0Nq7Coe6Tw8,9228
+xtgeo/grid3d/_gridprop_roxapi.py,sha256=4Aa4Vqzmml6RjePuRqyl68WeCxuICYv7p1u6KgL_R94,9262
 xtgeo/grid3d/_gridprop_value_init.py,sha256=xMAFhTKiZvq3QLcsYuuFRBBWzEQR9gxw7rMuj5ko5P4,4454
 xtgeo/grid3d/_gridprops_import_eclrun.py,sha256=M7hvBazZPjYsKOYBL1SHCcYqztgonARuQtXBQ_hyMdI,11782
 xtgeo/grid3d/_gridprops_import_roff.py,sha256=fCCMwa8OgLXk9zMvFpr4nfsKLkmBFKKLSfLwUHenyTA,2550
 xtgeo/grid3d/_roff_grid.py,sha256=kppx044-JmfLvaIt5NPABnIoLwJ1BGQc2gFeog7Cl0g,17742
 xtgeo/grid3d/_roff_parameter.py,sha256=9gVlFMyT2QbwUvm_FCJG0hTvJPrK2Y86kbeljs2eCbc,11376
-xtgeo/grid3d/grid.py,sha256=TcQzPUxUYHilN3qmgZ29wWLchNoRY714O_2uh94l15U,107808
+xtgeo/grid3d/grid.py,sha256=d628JbJ5VqM-jiCyyITCNflPbSo-9ESE_v0nGGNJKh0,109596
 xtgeo/grid3d/grid_properties.py,sha256=OlIyo1PXrTRFHGn8avXdBXNpFM5DJuLjVRB9koayKGQ,24993
-xtgeo/grid3d/grid_property.py,sha256=Fd1CC2_pSg4cLS7EGHHtDhSIk8w3VRrQ_fXUX3-1mMo,46687
+xtgeo/grid3d/grid_property.py,sha256=Wm9H6Nzqs8fSD35eg3NqTb-i6HGThsRmwbynZLg1nMo,45980
 xtgeo/grid3d/types.py,sha256=eaBHJL91zXV0ipaY30K_ZpEdUfjj681CoAbKfvNZ_5Q,290
 xtgeo/io/__init__.py,sha256=k5OQUG7ePoTleAh8ECiwowCg1imL6dx9O7gPUArcQQw,23
 xtgeo/io/_file.py,sha256=-bacKEMpbPMF1al3gqoV5pu0J57g26mRdSasxNk20Gg,21085
 xtgeo/metadata/__init__.py,sha256=VV81ga8OzzrowieSQZ5bZxo3Ug70Dch89iwZF1mOshA,337
-xtgeo/metadata/metadata.py,sha256=HD98hyOA1gb0nazvgE7KoXuGBMJ4wsQa1wi1tqL7GDM,12568
+xtgeo/metadata/metadata.py,sha256=0EVNcXXDh3mimYNZYW3FIYe3bXIzeEKRyqZOzBhu31E,12874
 xtgeo/roxutils/__init__.py,sha256=_f2qb32IFeZ_8YhcTDFlNgsWyH0HPDJQ7V0qUbjmUSs,99
 xtgeo/roxutils/_roxar_loader.py,sha256=mKg3SsHJDzaGEYQwuY2yPcTxOnCybKmq3IeLmteCJPg,1958
 xtgeo/roxutils/_roxutils_etc.py,sha256=Lma5Hskrld2PDLicSTkASse2t3eqxvtnure9uDCyjxo,3852
@@ -111,7 +111,7 @@ xtgeo/xyz/_xyz_oper.py,sha256=_uCR-PYEsPQkBKh82oDvUsz7Y2vqsjqoiEdfmd8HIEU,20058
 xtgeo/xyz/_xyz_roxapi.py,sha256=NWgnPShA8amuHgSTqvy5_y21Qyx2s_6IWP1qPyHTPb8,26585
 xtgeo/xyz/points.py,sha256=UhcdR7nEw3Lxa496UMOWOm5IkpQLC_IRU0FcFLpEV-o,23253
 xtgeo/xyz/polygons.py,sha256=JjvA5BiW0HzaVmuZjnKB55n0OJXZfjOBQHfSNcZBDiA,28791
-xtgeo-4.10.1.dist-info/METADATA,sha256=BgjBbVjXQOmIf5Rb2f9KsWqpP5CMTilfqnLgm5kLzqw,5789
-xtgeo-4.10.1.dist-info/WHEEL,sha256=jS-OUpQ7pzysZBq4lYO_axuVXwmbi12-xcZ3P0PA_yc,106
-xtgeo-4.10.1.dist-info/licenses/LICENSE.md,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-xtgeo-4.10.1.dist-info/RECORD,,
+xtgeo-4.12.0.dist-info/METADATA,sha256=au9aO7YlUYU5YAt5jB5uAwdsSjIqhAuyWSmIMUt7TYI,5741
+xtgeo-4.12.0.dist-info/WHEEL,sha256=chqeLhPBtPdrOoreR34YMcofSk3yWDQhkrsDJ2n48LU,106
+xtgeo-4.12.0.dist-info/licenses/LICENSE.md,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+xtgeo-4.12.0.dist-info/RECORD,,

{xtgeo-4.10.1.dist-info → xtgeo-4.12.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.4
+Generator: scikit-build-core 0.11.6
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64