xtgeo 4.13.0__cp310-cp310-win_amd64.whl → 4.13.1__cp310-cp310-win_amd64.whl

cxtgeo.py

@@ -475,12 +475,6 @@ def grd3d_get_lay_slice(nx, ny, nz, swig_np_dbl_in_v1, swig_np_dbl_in_v2, swig_n
 def grd3d_make_z_consistent(nx, ny, nz, swig_np_dbl_inplace_v1, zsep):
     return _cxtgeo.grd3d_make_z_consistent(nx, ny, nz, swig_np_dbl_inplace_v1, zsep)
 
-def grd3d_translate(nx, ny, nz, xflip, yflip, zflip, xshift, yshift, zshift, swig_np_dbl_inplace_v1, swig_np_dbl_inplace_v2):
-    return _cxtgeo.grd3d_translate(nx, ny, nz, xflip, yflip, zflip, xshift, yshift, zshift, swig_np_dbl_inplace_v1, swig_np_dbl_inplace_v2)
-
-def grd3d_reverse_jrows(nx, ny, nz, swig_np_dbl_inplace_v1, swig_np_dbl_inplace_v2, swig_np_int_inplace_v1):
-    return _cxtgeo.grd3d_reverse_jrows(nx, ny, nz, swig_np_dbl_inplace_v1, swig_np_dbl_inplace_v2, swig_np_int_inplace_v1)
-
 def grd3d_point_val_crange(x, y, z, nx, ny, nz, p_coor_v, zcornsv, actnumsv, p_val_v, value, imin, imax, jmin, jmax, kmin, kmax, ibs, option):
     return _cxtgeo.grd3d_point_val_crange(x, y, z, nx, ny, nz, p_coor_v, zcornsv, actnumsv, p_val_v, value, imin, imax, jmin, jmax, kmin, kmax, ibs, option)
 

cxtgeoPYTHON_wrap.c

@@ -14740,208 +14740,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_grd3d_translate(PyObject *self, PyObject *args) {
-  PyObject *resultobj = 0;
-  int arg1 ;
-  int arg2 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
-  int arg6 ;
-  double arg7 ;
-  double arg8 ;
-  double arg9 ;
-  double *arg10 = (double *) 0 ;
-  long arg11 ;
-  double *arg12 = (double *) 0 ;
-  long arg13 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  int val4 ;
-  int ecode4 = 0 ;
-  int val5 ;
-  int ecode5 = 0 ;
-  int val6 ;
-  int ecode6 = 0 ;
-  double val7 ;
-  int ecode7 = 0 ;
-  double val8 ;
-  int ecode8 = 0 ;
-  double val9 ;
-  int ecode9 = 0 ;
-  PyArrayObject *array10 = NULL ;
-  int i10 = 1 ;
-  PyArrayObject *array12 = NULL ;
-  int i12 = 1 ;
-  PyObject *swig_obj[11] ;
-  int result;
-  
-  (void)self;
-  if (!SWIG_Python_UnpackTuple(args, "grd3d_translate", 11, 11, swig_obj)) SWIG_fail;
-  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "grd3d_translate" "', argument " "1"" of type '" "int""'");
-  } 
-  arg1 = (int)(val1);
-  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "grd3d_translate" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = (int)(val2);
-  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "grd3d_translate" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = (int)(val3);
-  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "grd3d_translate" "', argument " "4"" of type '" "int""'");
-  } 
-  arg4 = (int)(val4);
-  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "grd3d_translate" "', argument " "5"" of type '" "int""'");
-  } 
-  arg5 = (int)(val5);
-  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "grd3d_translate" "', argument " "6"" of type '" "int""'");
-  } 
-  arg6 = (int)(val6);
-  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
-  if (!SWIG_IsOK(ecode7)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "grd3d_translate" "', argument " "7"" of type '" "double""'");
-  } 
-  arg7 = (double)(val7);
-  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
-  if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "grd3d_translate" "', argument " "8"" of type '" "double""'");
-  } 
-  arg8 = (double)(val8);
-  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
-  if (!SWIG_IsOK(ecode9)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "grd3d_translate" "', argument " "9"" of type '" "double""'");
-  } 
-  arg9 = (double)(val9);
-  {
-    array10 = obj_to_array_no_conversion(swig_obj[9], NPY_DOUBLE);
-    if (!array10 || !require_dimensions(array10,1) || !require_contiguous(array10)
-      || !require_native(array10)) SWIG_fail;
-    arg10 = (double*) array_data(array10);
-    arg11 = 1;
-    for (i10=0; i10 < array_numdims(array10); ++i10) arg11 *= array_size(array10,i10);
-  }
-  {
-    array12 = obj_to_array_no_conversion(swig_obj[10], NPY_DOUBLE);
-    if (!array12 || !require_dimensions(array12,1) || !require_contiguous(array12)
-      || !require_native(array12)) SWIG_fail;
-    arg12 = (double*) array_data(array12);
-    arg13 = 1;
-    for (i12=0; i12 < array_numdims(array12); ++i12) arg13 *= array_size(array12,i12);
-  }
-  {
-    char *err;
-    clear_exception();
-    result = (int)grd3d_translate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
-    if ((err = check_exception())) {
-      PyErr_SetString(PY_XTGeoCLibError, err);
-      return NULL;
-    }
-  }
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_grd3d_reverse_jrows(PyObject *self, PyObject *args) {
-  PyObject *resultobj = 0;
-  int arg1 ;
-  int arg2 ;
-  int arg3 ;
-  double *arg4 = (double *) 0 ;
-  long arg5 ;
-  double *arg6 = (double *) 0 ;
-  long arg7 ;
-  int *arg8 = (int *) 0 ;
-  long arg9 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
-  PyArrayObject *array4 = NULL ;
-  int i4 = 1 ;
-  PyArrayObject *array6 = NULL ;
-  int i6 = 1 ;
-  PyArrayObject *array8 = NULL ;
-  int i8 = 1 ;
-  PyObject *swig_obj[6] ;
-  int result;
-  
-  (void)self;
-  if (!SWIG_Python_UnpackTuple(args, "grd3d_reverse_jrows", 6, 6, swig_obj)) SWIG_fail;
-  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "grd3d_reverse_jrows" "', argument " "1"" of type '" "int""'");
-  } 
-  arg1 = (int)(val1);
-  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "grd3d_reverse_jrows" "', argument " "2"" of type '" "int""'");
-  } 
-  arg2 = (int)(val2);
-  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "grd3d_reverse_jrows" "', argument " "3"" of type '" "int""'");
-  } 
-  arg3 = (int)(val3);
-  {
-    array4 = obj_to_array_no_conversion(swig_obj[3], NPY_DOUBLE);
-    if (!array4 || !require_dimensions(array4,1) || !require_contiguous(array4)
-      || !require_native(array4)) SWIG_fail;
-    arg4 = (double*) array_data(array4);
-    arg5 = 1;
-    for (i4=0; i4 < array_numdims(array4); ++i4) arg5 *= array_size(array4,i4);
-  }
-  {
-    array6 = obj_to_array_no_conversion(swig_obj[4], NPY_DOUBLE);
-    if (!array6 || !require_dimensions(array6,1) || !require_contiguous(array6)
-      || !require_native(array6)) SWIG_fail;
-    arg6 = (double*) array_data(array6);
-    arg7 = 1;
-    for (i6=0; i6 < array_numdims(array6); ++i6) arg7 *= array_size(array6,i6);
-  }
-  {
-    array8 = obj_to_array_no_conversion(swig_obj[5], NPY_INT);
-    if (!array8 || !require_dimensions(array8,1) || !require_contiguous(array8)
-      || !require_native(array8)) SWIG_fail;
-    arg8 = (int*) array_data(array8);
-    arg9 = 1;
-    for (i8=0; i8 < array_numdims(array8); ++i8) arg9 *= array_size(array8,i8);
-  }
-  {
-    char *err;
-    clear_exception();
-    result = (int)grd3d_reverse_jrows(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
-    if ((err = check_exception())) {
-      PyErr_SetString(PY_XTGeoCLibError, err);
-      return NULL;
-    }
-  }
-  resultobj = SWIG_From_int((int)(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_grd3d_point_val_crange(PyObject *self, PyObject *args) {
   PyObject *resultobj = 0;
   double arg1 ;
@@ -19124,8 +18922,6 @@ static PyMethodDef SwigMethods[] = {
 	 { "grd3d_reduce_onelayer", _wrap_grd3d_reduce_onelayer, METH_VARARGS, NULL},
 	 { "grd3d_get_lay_slice", _wrap_grd3d_get_lay_slice, METH_VARARGS, NULL},
 	 { "grd3d_make_z_consistent", _wrap_grd3d_make_z_consistent, METH_VARARGS, NULL},
-	 { "grd3d_translate", _wrap_grd3d_translate, METH_VARARGS, NULL},
-	 { "grd3d_reverse_jrows", _wrap_grd3d_reverse_jrows, METH_VARARGS, NULL},
 	 { "grd3d_point_val_crange", _wrap_grd3d_point_val_crange, METH_VARARGS, NULL},
 	 { "grd3d_point_in_cell", _wrap_grd3d_point_in_cell, METH_VARARGS, NULL},
 	 { "grd3d_get_randomline", _wrap_grd3d_get_randomline, METH_VARARGS, NULL},

xtgeo/common/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.13.0'
-__version_tuple__ = version_tuple = (4, 13, 0)
+__version__ = version = '4.13.1'
+__version_tuple__ = version_tuple = (4, 13, 1)
 
-__commit_id__ = commit_id = 'g766805bb7'
+__commit_id__ = commit_id = 'gdae14dc56'

xtgeo/grid3d/_grid_etc1.py

@@ -1259,85 +1259,86 @@ def reduce_to_one_layer(self: Grid) -> None:
     self._subgrids = None
 
 
-def translate_coordinates(
-    self: Grid,
-    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
-    flip: tuple[int, int, int] = (1, 1, 1),
+def reverse_row_axis(
+    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
 ) -> None:
-    """Translate grid coordinates."""
-    self._set_xtgformat1()
+    """Flip the row-axis for xtgformat=2 grid arrays.
 
-    tx, ty, tz = translate
-    fx, fy, fz = flip
+    This reverses the J-direction (rows) by flipping along axis 1 for both
+    coordsv and zcornsv arrays, and also handles the corner ordering within
+    each pillar to maintain proper geometry.
+    """
+    if ijk_handedness == self.ijk_handedness:
+        return
 
-    ier = _cxtgeo.grd3d_translate(
-        self._ncol,
-        self._nrow,
-        self._nlay,
-        fx,
-        fy,
-        fz,
-        tx,
-        ty,
-        tz,
-        self._coordsv,
-        self._zcornsv,
-    )
-    if ier != 0:
-        raise RuntimeError(f"Something went wrong in translate, code: {ier}")
+    self._set_xtgformat2()
 
-    logger.info("Translation of coords done")
+    # Flip coordsv along the row axis (axis 1) and make contiguous with copy()
+    self._coordsv = np.flip(self._coordsv, axis=1).copy()
 
+    # For zcornsv, we need to flip along row axis and also swap corner ordering
+    # Original corner order: SW, SE, NW, NE (indices 0,1,2,3)
+    # After row flip: NW, NE, SW, SE (should become indices 0,1,2,3)
+    # So we need to rearrange: [2,3,0,1]
+    zcorns_flipped = np.flip(self._zcornsv, axis=1)  # Flip along row axis
+    self._zcornsv = zcorns_flipped[:, :, :, [2, 3, 0, 1]].copy()  # Reorder corners
 
-def reverse_row_axis(
-    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
-) -> None:
-    """Reverse rows (aka flip) for geometry and assosiated properties."""
-    if ijk_handedness == self.ijk_handedness:
-        return
+    # Also flip actnum along row axis
+    self._actnumsv = np.flip(self._actnumsv, axis=1).copy()
 
-    # update the handedness
-    if ijk_handedness is None:
-        self._ijk_handedness = estimate_handedness(self)
+    # Update handedness
+    if self._ijk_handedness == "left":
+        self._ijk_handedness = "right"
+    else:
+        self._ijk_handedness = "left"
 
-    original_handedness = self._ijk_handedness
-    original_xtgformat = self._xtgformat
+    # Handle properties if they exist
+    if self._props and self._props.props:
+        for prop in self._props.props:
+            prop.values = np.flip(prop.values, axis=1).copy()
 
-    self._set_xtgformat1()
+    logger.info("Reversing of row axis done")
 
-    ier = _cxtgeo.grd3d_reverse_jrows(
-        self._ncol,
-        self._nrow,
-        self._nlay,
-        self._coordsv.ravel(),
-        self._zcornsv.ravel(),
-        self._actnumsv.ravel(),
-    )
 
-    if ier != 0:
-        raise RuntimeError(f"Something went wrong in jswapping, code: {ier}")
+def reverse_column_axis(
+    self: Grid, ijk_handedness: Literal["left", "right"] | None = None
+) -> None:
+    """Flip the column-axis for xtgformat=2 grid arrays.
 
-    if self._props is None:
+    This reverses the I-direction (columns) by flipping along axis 0 for both
+    coordsv and zcornsv arrays, and also handles the corner ordering within
+    each pillar to maintain proper geometry.
+    """
+    if ijk_handedness == self.ijk_handedness:
         return
 
-    # do it for properties
-    if self._props.props:
-        for prp in self._props.props:
-            prp.values = prp.values[:, ::-1, :]
+    self._set_xtgformat2()
+
+    # Flip coordsv along the column axis (axis 0) and make contiguous with copy()
+    self._coordsv = np.flip(self._coordsv, axis=0).copy()
+
+    # For zcornsv, we need to flip along column axis and also swap corner ordering
+    # Original corner order: SW, SE, NW, NE (indices 0,1,2,3)
+    # After column flip: SE, SW, NE, NW (should become indices 0,1,2,3)
+    # So we need to rearrange: [1,0,3,2]
+    zcorns_flipped = np.flip(self._zcornsv, axis=0)  # Flip along column axis
+    self._zcornsv = zcorns_flipped[:, :, :, [1, 0, 3, 2]].copy()  # Reorder corners
 
-    # update the handedness
-    if ijk_handedness is None:
-        self._ijk_handedness = estimate_handedness(self)
+    # Also flip actnum along column axis
+    self._actnumsv = np.flip(self._actnumsv, axis=0).copy()
 
-    if original_handedness == "left":
+    # Update handedness
+    if self._ijk_handedness == "left":
         self._ijk_handedness = "right"
     else:
         self._ijk_handedness = "left"
 
-    if original_xtgformat == 2:
-        self._set_xtgformat2()
+    # Handle properties if they exist
+    if self._props and self._props.props:
+        for prop in self._props.props:
+            prop.values = np.flip(prop.values, axis=0).copy()
 
-    logger.info("Reversing of rows done")
+    logger.info("Reversing of column axis done")
 
 
 def get_adjacent_cells(

xtgeo/grid3d/_grid_translate_coords.py

@@ -0,0 +1,154 @@
+"""Private module for translating coordiantes plus flipping and rotation."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+
+
+def _rotate_grid3d(
+    new_grd: Grid, add_rotation: float, rotation_xy: tuple[float, float] | None = None
+) -> None:
+    """Rotate the grid around the cell 1,1,1 corner, or some other coordinate."""
+
+    # Convert angle to radians
+    angle_rad = math.radians(add_rotation)
+
+    # Create rotation matrix coefficients
+    cos_theta = math.cos(angle_rad)
+    sin_theta = math.sin(angle_rad)
+
+    # extract
+    coord_array = new_grd._coordsv.copy()
+    rotated_coords = coord_array.copy()
+
+    if rotation_xy is None:
+        x0, y0, _ = new_grd._coordsv[0, 0, :3]
+    else:
+        x0, y0 = rotation_xy
+
+    x_coords = coord_array[:, :, [0, 3]].copy()  # x1 and x2
+    y_coords = coord_array[:, :, [1, 4]].copy()  # y1 and y2
+
+    # Translate to origin
+    x_translated = x_coords - x0
+    y_translated = y_coords - y0
+
+    # Rotate using rotation matrix
+    x_rotated = x_translated * cos_theta - y_translated * sin_theta
+    y_rotated = x_translated * sin_theta + y_translated * cos_theta
+
+    # Translate back and assign
+    rotated_coords[:, :, [0, 3]] = x_rotated + x0
+    rotated_coords[:, :, [1, 4]] = y_rotated + y0
+
+    # Z coordinates remain unchanged (indices 2 and 5)
+    new_grd._coordsv = rotated_coords.copy()
+
+
+def _flip_vertically(grid: Grid) -> None:
+    """Flip the grid vertically."""
+
+    # find average depth of corners
+    avg_z = grid._zcornsv.mean()
+
+    grid._zcornsv = grid._zcornsv[:, :, ::-1, :]
+    grid._zcornsv *= -1
+
+    # find the new average and compute the difference for shifting
+    new_avg_z = grid._zcornsv.mean()
+    diff = avg_z - new_avg_z
+    grid._zcornsv += diff
+
+    grid._actnumsv = np.flip(grid._actnumsv, axis=2).copy()
+
+    # Handle properties if they exist
+    if grid._props and grid._props.props:
+        for prop in grid._props.props:
+            prop.values = np.flip(prop.values, axis=2).copy()
+
+    # When we flip the grid, the subgrid info must also be flipped
+    subgrids = grid.get_subgrids()
+    if subgrids:
+        reverted = dict(reversed(subgrids.items()))
+        grid.set_subgrids(reverted)
+
+    if grid._ijk_handedness == "left":
+        grid._ijk_handedness = "right"
+    else:
+        grid._ijk_handedness = "left"
+
+
+def _translate_geometry(grid: Grid, translate: tuple[float, float, float]) -> None:
+    grid._coordsv[:, :, 0] += translate[0]
+    grid._coordsv[:, :, 1] += translate[1]
+    grid._coordsv[:, :, 2] += translate[2]
+    grid._coordsv[:, :, 3] += translate[0]
+    grid._coordsv[:, :, 4] += translate[1]
+    grid._coordsv[:, :, 5] += translate[2]
+
+    grid._zcornsv += translate[2]
+
+
+def _transfer_to_target(grid: Grid, target: tuple[float, float, float]) -> None:
+    # get the coordinates for the active cells
+    x, y, z = grid.get_xyz(asmasked=True)
+
+    # set the grid center to the desired target coordinates
+    shift_x = target[0] - x.values.mean()
+    shift_y = target[1] - y.values.mean()
+    shift_z = target[2] - z.values.mean()
+
+    _translate_geometry(grid, (shift_x, shift_y, shift_z))
+
+
+def translate_coordinates(
+    self: Grid,
+    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    flip: tuple[int, int, int] = (1, 1, 1),
+    add_rotation: float = 0.0,
+    rotation_point: tuple[float, float] | None = None,
+    target_coordinates: tuple[float, float, float] | None = None,
+) -> None:
+    """Rotate, flip grid and translate grid coordinates.
+
+    This should be done in a sequence like this
+    1) Add rotation (with value ``add_rotation``) to rotate the grid counter-clockwise
+    2) Flip the grid
+    3a) translate the grid by adding (x, y, z), OR
+    3b) set a target location the grid centre.
+
+    """
+    self._set_xtgformat2()
+
+    if abs(add_rotation) > 1e-10:  # Skip rotation if angle is essentially zero
+        _rotate_grid3d(self, add_rotation, rotation_xy=rotation_point)
+
+    if flip[2] == -1:
+        _flip_vertically(self)
+
+    if flip[0] == -1:
+        self.reverse_column_axis()
+
+    if flip[1] == -1:
+        self.reverse_row_axis()
+
+    use_translate = False
+    if not all(abs(x) < 1e-10 for x in translate):
+        _translate_geometry(self, translate)
+        use_translate = True
+
+    if target_coordinates and use_translate:
+        raise ValueError(
+            "Using both key 'translate' and key 'target_coordinates' is not allowed. "
+            "Use either."
+        )
+
+    if target_coordinates:
+        # transfer the grid's geometrical centre to a given location
+        _transfer_to_target(self, target_coordinates)

xtgeo/grid3d/grid.py

@@ -28,6 +28,7 @@ from . import (
     _grid_import_ecl,
     _grid_refine,
     _grid_roxapi,
+    _grid_translate_coords,
     _grid_wellzone,
     _gridprop_lowlevel,
 )
@@ -2480,21 +2481,48 @@ class Grid(_Grid3D):
     def translate_coordinates(
         self,
         translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+        target_coordinates: tuple[float, float, float] | None = None,
         flip: tuple[int, int, int] = (1, 1, 1),
-    ) -> None:
-        """Translate (move) and/or flip grid coordinates in 3D.
+        add_rotation: float = 0.0,
+        rotation_point: tuple[float, float] | None = None,
+    ) -> Grid | None:
+        """Translate (move), flip and rotate the 3D grid geometry.
 
-        By 'flip' here, it means that the full coordinate array are multiplied
-        with -1.
+        By 'flip' here, it means that the full coordinate arrays are inverted.
 
         Args:
-            translate (tuple): Translation distance in X, Y, Z coordinates
-            flip (tuple): Flip array. The flip values must be 1 or -1.
+            translate: Translation distance in X, Y, Z coordinates; these
+                values will be added to the current coordinates.
+            target_coordinates: Position for the centerpoint of the active grid cells.
+                Note that key ``translate`` cannot be used with this key; i.e. use
+                either ``translate`` or ``target_coordinates``
+            flip: Flip array. The flip values must be 1 or -1, meaning 1 for
+                keeping the current, and -1 for activating an axis flip.
+            add_rotation: The grid geometry will get an additional rotation by this
+                value, in degrees and counter clock wise.
+            rotation_point: Which (x, y) coordiate to be set as origin when adding
+                rotation. Default is the corner of the first cell number.
+
+        Note:
+            Grid properties attached to the grid will also be transformed
+
+        Example::
+            import xtgeo
+            grd = xtgeo.grid_from_roxar(project, "simpleb8")
+            poro = xtgeo.gridproperty_from_roxar(project, "simpleb8", "PORO")
+            grd.props = [poro]
+
+            grd.translate_coordinates(translate=(10,10, 20), flip=(1,1,-1),
+                add_rotation=30)
+
+            grd.to_roxar(project, "simpleb8_translated")
+            poro1 = grd.get_prop_by_name("PORO")
+            poro1.to_roxar(project, "simpleb8_translated", "PORO")
 
-        Raises:
-            RuntimeError: If translation goes wrong for unknown reasons
         """
-        _grid_etc1.translate_coordinates(self, translate=translate, flip=flip)
+        _grid_translate_coords.translate_coordinates(
+            self, translate, flip, add_rotation, rotation_point, target_coordinates
+        )
 
     def reverse_row_axis(
         self, ijk_handedness: Literal["left", "right"] | None = None
@@ -2502,7 +2530,7 @@ class Grid(_Grid3D):
         """Reverse the row axis (J indices).
 
         This means that IJK system will switched between a left vs right handed system.
-        It is here (by using ijk_handedness key), possible to set a wanted stated.
+        It is here (by using ijk_handedness key), possible to set a wanted handedness.
 
         Note that properties that are assosiated with the grid (through the
         :py:attr:`~gridprops` or :py:attr:`~props` attribute) will also be
@@ -2528,6 +2556,38 @@ class Grid(_Grid3D):
         """
         _grid_etc1.reverse_row_axis(self, ijk_handedness=ijk_handedness)
 
+    def reverse_column_axis(
+        self, ijk_handedness: Literal["left", "right"] | None = None
+    ) -> None:
+        """Reverse the column axis (I indices).
+
+        This means that IJK system will switched between a left vs right handed system.
+        It is here (by using ijk_handedness key), possible to set a wanted handedness.
+
+        Note that properties that are assosiated with the grid (through the
+        :py:attr:`~gridprops` or :py:attr:`~props` attribute) will also be
+        reversed (which is desirable).
+
+        Args:
+            ijk_handedness (str): If set to "right" or "left", do only reverse columns
+                if handedness is not already achieved.
+
+        Example::
+
+            grd = xtgeo.grid_from_file("somefile.roff")
+            prop1 = xtgeo.gridproperty_from_file("somepropfile1.roff")
+            prop2 = xtgeo.gridproperty_from_file("somepropfile2.roff")
+
+            grd.props = [prop1, prop2]
+
+            # secure that the grid geometry is IJK right-handed
+            grd.reverse_column_axis(ijk_handedness="right")
+
+        .. versionadded:: 4.14
+
+        """
+        _grid_etc1.reverse_column_axis(self, ijk_handedness=ijk_handedness)
+
     def make_zconsistent(self, zsep: float | int = 1e-5) -> None:
         """Make the 3D grid consistent in Z, by a minimal gap (zsep).
 

xtgeo/io/_file.py

@@ -227,7 +227,7 @@ class FileWrapper:
             date = obj.metadata.opt.datetime  # type: ignore
             newname = short + "--" + desc
             if date:
-                newname += "--" + date
+                newname += "--" + str(date)
         else:
             # return without modifications of self._file to avoid with_suffix() issues
             # if the file name stem itself contains multiple '.'

xtgeo/metadata/metadata.py

@@ -21,6 +21,12 @@ from xtgeo.common.log import null_logger
 if TYPE_CHECKING:
     from datetime import datetime
 
+    from xtgeo.cube.cube1 import Cube
+    from xtgeo.grid3d.grid import Grid, GridProperty
+    from xtgeo.surface.regular_surface import RegularSurface
+    from xtgeo.well.well1 import Well
+
+
 logger = null_logger(__name__)
 
 
@@ -56,11 +62,11 @@ class _OptionalMetaData:
     def __init__(self) -> None:
         self._name = "A Longer Descriptive Name e.g. from SMDA"
         self._shortname = "TheShortName"
-        self._datatype = None
+        self._datatype: str | None = None
         self._md5sum: str | None = None
         self._description = "Some description"
         self._crs = None
-        self._datetime: datetime | None = None
+        self._datetime: datetime | str | None = None
         self._deltadatetime = None
         self._visuals = {"colortable": "rainbow", "lower": None, "upper": None}
         self._domain = "depth"
@@ -84,11 +90,11 @@ class _OptionalMetaData:
         self._name = newname
 
     @property
-    def datetime(self) -> datetime | None:
+    def datetime(self) -> datetime | str | None:
         return self._datetime
 
     @datetime.setter
-    def datetime(self, newdate: datetime) -> None:
+    def datetime(self, newdate: datetime | str) -> None:
         # TODO: validation
         self._datetime = newdate
 
@@ -147,15 +153,15 @@ class _OptionalMetaData:
 class MetaData:
     """Generic metadata class, not intended to be used directly."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Generic metadata class __init__, not be used directly."""
-        self._required = {}
+        self._required: dict[str, Any] = {}
         self._optional = _OptionalMetaData()
         self._freeform = {}
 
         self._freeform = {"smda": "whatever"}
 
-    def get_metadata(self):
+    def get_metadata(self) -> dict[str, Any]:
         """Get all metadata that are present."""
         allmeta = {}
         allmeta["_required_"] = self._required
@@ -164,7 +170,7 @@ class MetaData:
         return allmeta
 
     @property
-    def optional(self):
+    def optional(self) -> dict[str, Any]:
         """Return or set optional metadata.
 
         When setting optional names, it can be done in several ways...
@@ -176,7 +182,7 @@ class MetaData:
         return self._optional.get_meta()
 
     @optional.setter
-    def optional(self, indict):
+    def optional(self, indict: dict[str, Any]) -> None:
         # setting the optional key, including validation
         if not isinstance(indict, dict):
             raise ValueError(f"Input must be a dictionary, not a {type(indict)}")
@@ -185,7 +191,7 @@ class MetaData:
             setattr(self._optional, "_" + key, value)
 
     @property
-    def opt(self):
+    def opt(self) -> _OptionalMetaData:
         """Return the metadata optional instance.
 
         This makes access to the _OptionalMetaData instance.
@@ -198,26 +204,17 @@ class MetaData:
         """
         return self._optional
 
-    @optional.setter
-    def optional(self, indict):
-        # setting the optional key, including validation
-        if not isinstance(indict, dict):
-            raise ValueError(f"Input must be a dictionary, not a {type(indict)}")
-
-        for key, value in indict.items():
-            setattr(self._optional, "_" + key, value)
-
     @property
-    def freeform(self):
+    def freeform(self) -> dict[str, Any]:
         """Get or set the current freeform metadata dictionary."""
         return self._freeform
 
     @freeform.setter
-    def freeform(self, adict):
+    def freeform(self, adict: dict[str, Any]) -> None:
         """Freeform is a whatever you want set, without any validation."""
         self._freeform = adict.copy()
 
-    def generate_fmu_name(self):
+    def generate_fmu_name(self) -> str:
         """Generate FMU name on form xxxx--yyyy--date but no suffix."""
         fname = ""
         first = "prefix"
@@ -233,7 +230,7 @@ class MetaData:
 class MetaDataRegularSurface(MetaData):
     """Metadata for RegularSurface() objects."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "xori": 0.0,
@@ -245,20 +242,20 @@ class MetaDataRegularSurface(MetaData):
         "undef": UNDEF,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "Regular Surface"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.RegularSurface):
+    def required(self, obj: RegularSurface) -> None:
+        if not isinstance(obj, xtgeo.RegularSurface):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a RegularSurface()")
 
         self._required["ncol"] = obj.ncol
@@ -276,7 +273,7 @@ class MetaDataRegularCube(MetaData):
     """Metadata for Cube() objects."""
 
     # allowed optional keys; these are set to avoid discussions
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "nlay": 1,
@@ -292,20 +289,20 @@ class MetaDataRegularCube(MetaData):
         "undef": UNDEF,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "Regular Cube"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.Cube):
+    def required(self, obj: Cube) -> None:
+        if not isinstance(obj, xtgeo.Cube):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a regular Cube()")
 
         self._required["ncol"] = obj.ncol
@@ -326,7 +323,7 @@ class MetaDataRegularCube(MetaData):
 class MetaDataCPGeometry(MetaData):
     """Metadata for Grid() objects of type simplified CornerPoint Geometry."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "nlay": 1,
@@ -338,20 +335,20 @@ class MetaDataCPGeometry(MetaData):
         "zscale": 1.0,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "CornerPoint GridGeometry"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.Grid):
+    def required(self, obj: Grid) -> None:
+        if not isinstance(obj, xtgeo.Grid):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a Grid()")
 
         self._required["ncol"] = obj.ncol
@@ -369,7 +366,7 @@ class MetaDataCPGeometry(MetaData):
 class MetaDataCPProperty(MetaData):
     """Metadata for GridProperty() objects belonging to CPGeometry."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "nlay": 1,
@@ -377,20 +374,20 @@ class MetaDataCPProperty(MetaData):
         "discrete": False,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "CornerPoint GridProperty"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.GridProperty):
+    def required(self, obj: GridProperty) -> None:
+        if not isinstance(obj, xtgeo.GridProperty):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a GridProperty()")
 
         self._required["ncol"] = obj.ncol
@@ -403,7 +400,7 @@ class MetaDataCPProperty(MetaData):
 class MetaDataWell(MetaData):
     """Metadata for single Well() objects."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "rkb": 0.0,
         "xpos": 0.0,
         "ypos": 0.0,
@@ -413,20 +410,20 @@ class MetaDataWell(MetaData):
         "zonelogname": None,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialisation for Well metadata."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "Well"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.Well):
+    def required(self, obj: Well) -> None:
+        if not isinstance(obj, xtgeo.Well):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a Well() instance!")
 
         self._required["rkb"] = obj.rkb

{xtgeo-4.13.0.dist-info → xtgeo-4.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xtgeo
-Version: 4.13.0
+Version: 4.13.1
 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>

{xtgeo-4.13.0.dist-info → xtgeo-4.13.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-cxtgeo.py,sha256=LpfocX7SkcH-Mm-gU7vK4ZnVJVGhAaoQVXTt00YOmlA,32678
-cxtgeoPYTHON_wrap.c,sha256=Jqhwcya3gd-D86SRQpO3t0tfguuj2ODX64spcw_HxVg,636863
+cxtgeo.py,sha256=Am9tF-v-D87wEB9lzenKD601MEQUDVLkgy0ZL0eZ2zw,32172
+cxtgeoPYTHON_wrap.c,sha256=NAOsLVPMklaVIaeRS9Z-k2-obR5na8HnUEQrWS6HfGM,629898
 xtgeo/__init__.py,sha256=edNCOXuPS5qjutDGX5-2Pz0T2Lpx1GoeG3IoeXUdBw8,5834
-xtgeo/_cxtgeo.cp310-win_amd64.pyd,sha256=IyTIp83sCRzmeVpYnik-tO1zOws08nzuY4sb0GV5gg4,696320
-xtgeo/_internal.cp310-win_amd64.pyd,sha256=WDwFCs25sHRrsrCn9-L3x96W61DfZXMb89YXyHWJG1I,1104896
+xtgeo/_cxtgeo.cp310-win_amd64.pyd,sha256=p3K4lf3DJi_xnckBuYJS8aVEAaJqkmcvd95L7V65RKk,688128
+xtgeo/_internal.cp310-win_amd64.pyd,sha256=Q03QOfCGXKpoXpBohqp0An9GRC3ZdynsbBdp92dg9wU,1104896
 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,7 +12,7 @@ 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=3GfILrgbGmS7LIafEAcI93zYnldfjDfKDxNluh7L6I0,748
+xtgeo/common/version.py,sha256=OGkAupIM0EdocaPdwDfusf_WN0L4C7ZBzaQIrLvgxxw,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
@@ -34,7 +34,7 @@ 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=DBq1__wemVhjfk42HrADrwwygXbb0DckEvSvYue0yHo,45551
+xtgeo/grid3d/_grid_etc1.py,sha256=wrZhrqxM2_1NTgGawQyyy0WWN-bGRMdE1t7yFd6RxlU,46602
 xtgeo/grid3d/_grid_export.py,sha256=G36va-Kz93W-P2z8Qr-0Dq-o7Abfsd3OC8ESCAFRh2M,7492
 xtgeo/grid3d/_grid_hybrid.py,sha256=jMkLIEkab3f9_I8cKAc9wKczZZ3HpBFhwYwyBme6fe4,1305
 xtgeo/grid3d/_grid_import.py,sha256=Y11JDjf5tZkDth69aTtbkMfMjRbVvSnQbV3lt-jCuA8,2672
@@ -43,6 +43,7 @@ xtgeo/grid3d/_grid_import_roff.py,sha256=davWOUvCYPbvSFKm5bDCJJNPR-9uW_bOn4faGBh
 xtgeo/grid3d/_grid_import_xtgcpgeom.py,sha256=ZVqkf1QAvv8iDFZxV-2AhGimUjAdFcMwFml7yqocACU,10577
 xtgeo/grid3d/_grid_refine.py,sha256=jjYgBySFOE1qDaZwPshttkawjyVWPbHW1h3dj7qprQI,8816
 xtgeo/grid3d/_grid_roxapi.py,sha256=ixanN3VNGQM3QeVxXLHj_hKZJSiG3cdZwHc2NdXg_ms,9199
+xtgeo/grid3d/_grid_translate_coords.py,sha256=EvexYZyvtsTFsd2Pdg9UkmNXq8ZE2Q-jX0Dv48Ib8Lk,4850
 xtgeo/grid3d/_grid_wellzone.py,sha256=5OwMsmksC0Wza5XXfUiDHCzSLWqmV3JbSORDUFPXZho,5951
 xtgeo/grid3d/_gridprop_export.py,sha256=wKYm6UhRCrDwf74V_HuWvdlYKgET6iIm8i1fGpPgbGY,6735
 xtgeo/grid3d/_gridprop_import_eclrun.py,sha256=E8fgp5VFbJknoitP-t2JJv5LcIUuLutIDJuVXBS_ugE,5260
@@ -57,14 +58,14 @@ xtgeo/grid3d/_gridprops_import_eclrun.py,sha256=M7hvBazZPjYsKOYBL1SHCcYqztgonARu
 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=P-uO-wBiN1wok-RVpcICd49zW3iI86s9QpXwU7BPOT0,110086
+xtgeo/grid3d/grid.py,sha256=sjQnS-peWf1ZcI7P_NMJq-WQcrpHWLslTuDjdkCcY2c,112768
 xtgeo/grid3d/grid_properties.py,sha256=OlIyo1PXrTRFHGn8avXdBXNpFM5DJuLjVRB9koayKGQ,24993
 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/io/_file.py,sha256=ij_SgzZJTks4W9j0KX26qEHU0JTF9ZJCCklgajj0eQQ,21090
 xtgeo/metadata/__init__.py,sha256=VV81ga8OzzrowieSQZ5bZxo3Ug70Dch89iwZF1mOshA,337
-xtgeo/metadata/metadata.py,sha256=0EVNcXXDh3mimYNZYW3FIYe3bXIzeEKRyqZOzBhu31E,12874
+xtgeo/metadata/metadata.py,sha256=4avOpkzwPWV9HblUhRptvnOpKKfMk8tB4KiZPgwl1p4,13339
 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 +112,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=LObAxc8EC5-wxWFX8HJ9F-ouw0uoHdOpvswd-SIB8KQ,23280
 xtgeo/xyz/polygons.py,sha256=JjvA5BiW0HzaVmuZjnKB55n0OJXZfjOBQHfSNcZBDiA,28791
-xtgeo-4.13.0.dist-info/METADATA,sha256=g7Q3-TQzr0JfUPoAFqOJrNDHadbmRe_dqN2HoZChR2U,5779
-xtgeo-4.13.0.dist-info/WHEEL,sha256=hrGeChGtn46HBGmzasO9QQDSLelRN-tUarBSv4gFcsI,106
-xtgeo-4.13.0.dist-info/licenses/LICENSE.md,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-xtgeo-4.13.0.dist-info/RECORD,,
+xtgeo-4.13.1.dist-info/METADATA,sha256=20bqQS_a1pJsjxiMvqiW71i8Mv-k8gaMNxHxlF8dzgs,5779
+xtgeo-4.13.1.dist-info/WHEEL,sha256=hrGeChGtn46HBGmzasO9QQDSLelRN-tUarBSv4gFcsI,106
+xtgeo-4.13.1.dist-info/licenses/LICENSE.md,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+xtgeo-4.13.1.dist-info/RECORD,,