resdata 7.0.0b4__cp315-cp315-win_amd64.whl

resdata/__init__.py

@@ -0,0 +1,39 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'resdata.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_2()
+del _delvewheel_patch_1_13_2
+# end delvewheel patch
+
+import ctypes as ct
+import os
+import pathlib
+import warnings
+from importlib.util import find_spec
+
+warnings.filterwarnings(
+    action="always",
+    category=DeprecationWarning,
+    module="resdata",
+)
+
+from .rd_type import ResDataType, ResdataTypeEnum
+from .rd_util import (
+    FileMode,
+    FileType,
+    Phase,
+    ResdataUtil,
+    UnitSystem,
+)
+from .version import version as __version__
+
+
+def root():
+    """
+    Will print the filesystem root of the current ert package.
+    """
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), "../"))

resdata/_base_c_class.py

@@ -0,0 +1,96 @@
+import ctypes
+
+# PyCapsule_GetPointer extracts the raw void* address wrapped by an (unnamed)
+# capsule. Used only for equality/hashing/repr - never to reconstruct a typed
+# pointer for use by C++ code (that goes through cast_cwrap in C++ instead).
+_pycapsule_get_pointer = ctypes.pythonapi.PyCapsule_GetPointer
+_pycapsule_get_pointer.restype = ctypes.c_void_p
+_pycapsule_get_pointer.argtypes = (ctypes.py_object, ctypes.c_char_p)
+
+
+def _capsule_address(capsule):
+    if capsule is None:
+        return 0
+    return _pycapsule_get_pointer(capsule, None)
+
+
+class _BaseCClass:
+    def __new__(cls, *args, **kwargs):
+        obj = super().__new__(cls)
+        # Set safe defaults before __init__ runs, so that a __del__ call on a
+        # partially constructed object (e.g. because a subclass __init__
+        # raised before calling super().__init__()) does not itself raise an
+        # AttributeError - it will just see a None c_pointer and skip free().
+        obj.__c_pointer = None
+        obj.__parent = None
+        obj.__is_reference = False
+        return obj
+
+    def __init__(self, c_pointer, parent=None, is_reference=False):
+        if c_pointer is None:
+            raise ValueError("Must have a valid (not null) pointer value!")
+
+        self.__c_pointer = c_pointer
+        self.__parent = parent
+        self.__is_reference = is_reference
+
+    def setParent(self, parent):
+        self.__parent = parent
+        return self
+
+    def _ad_str(self):
+        return f"at 0x{_capsule_address(self.__c_pointer):x}"
+
+    def _create_repr(self, args=""):
+        return f"{self.__class__.__name__}({args}) {self._ad_str()}"
+
+    def free(self):
+        raise NotImplementedError(
+            "A _BaseCClass requires a free method implementation!"
+        )
+
+    def __del__(self):
+        if (
+            self.free is not None
+            and not self.__is_reference
+            and self.__c_pointer is not None
+        ):
+            # Important to check the c_pointer; in the case of failed object creation
+            # we can have a Python object with c_pointer == None.
+            self.free()
+
+    def __repr__(self):
+        return self._create_repr()
+
+    def __eq__(self, other):
+        if not isinstance(other, _BaseCClass):
+            return NotImplemented
+        return _capsule_address(self.__c_pointer) == _capsule_address(other.__c_pointer)
+
+    def __hash__(self):
+        return hash(_capsule_address(self.__c_pointer))
+
+    @classmethod
+    def createPythonObject(cls, c_pointer):
+        if c_pointer is not None:
+            new_obj = cls.__new__(cls)
+            _BaseCClass.__init__(
+                new_obj, c_pointer=c_pointer, parent=None, is_reference=False
+            )
+            return new_obj
+        else:
+            return None
+
+    @classmethod
+    def createCReference(cls, c_pointer, parent=None):
+        if c_pointer is not None:
+            new_obj = cls.__new__(cls)
+            _BaseCClass.__init__(
+                new_obj, c_pointer=c_pointer, parent=parent, is_reference=True
+            )
+            return new_obj
+        else:
+            return None
+
+
+__all__ = ["_BaseCClass"]

resdata/_rd_util.pyi

@@ -0,0 +1,85 @@
+import enum
+import typing
+
+__all__ = ["FileMode", "FileType", "Phase"]
+
+class FileMode:
+    CLOSE_STREAM: typing.ClassVar[FileMode]
+    DEFAULT: typing.ClassVar[FileMode]
+    WRITABLE: typing.ClassVar[FileMode]
+    __members__: typing.ClassVar[dict[str, FileMode]]
+    def __and__(self, arg0: FileMode) -> FileMode: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ge__(self, other: typing.Any) -> bool: ...
+    def __getstate__(self) -> int: ...
+    def __gt__(self, other: typing.Any) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: typing.SupportsInt) -> None: ...
+    def __int__(self) -> int: ...
+    def __invert__(self) -> FileMode: ...
+    def __le__(self, other: typing.Any) -> bool: ...
+    def __lt__(self, other: typing.Any) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __or__(self, arg0: FileMode) -> FileMode: ...
+    def __setstate__(self, state: typing.SupportsInt) -> None: ...
+    def __xor__(self, arg0: FileMode) -> FileMode: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
+
+class FileType:
+    DATA: typing.ClassVar[FileType]
+    EGRID: typing.ClassVar[FileType]
+    GRID: typing.ClassVar[FileType]
+    INIT: typing.ClassVar[FileType]
+    OTHER: typing.ClassVar[FileType]
+    RESTART: typing.ClassVar[FileType]
+    RFT: typing.ClassVar[FileType]
+    SUMMARY: typing.ClassVar[FileType]
+    SUMMARY_HEADER: typing.ClassVar[FileType]
+    UNIFIED_RESTART: typing.ClassVar[FileType]
+    UNIFIED_SUMMARY: typing.ClassVar[FileType]
+    __members__: typing.ClassVar[dict[str, FileType]]
+    def __eq__(self, other: object) -> bool: ...
+    def __getstate__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: typing.SupportsInt) -> None: ...
+    def __int__(self) -> int: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __setstate__(self, state: typing.SupportsInt) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
+
+def _get_file_type(filename: str) -> tuple[FileType, bool, int]: ...
+def _get_num_cpu(filename: str) -> int: ...
+def _get_report_step(filename: str) -> int: ...
+def _get_start_date(filename: str) -> int: ...
+
+class UnitSystem:
+    METRIC: typing.ClassVar[UnitSystem]
+    FIELD: typing.ClassVar[UnitSystem]
+    LAB: typing.ClassVar[UnitSystem]
+    PVT_M: typing.ClassVar[UnitSystem]
+    __members__: typing.ClassVar[dict[str, UnitSystem]]
+    def __eq__(self, other: object) -> bool: ...
+    def __getstate__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __init__(self, value: typing.SupportsInt) -> None: ...
+    def __int__(self) -> int: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __setstate__(self, state: typing.SupportsInt) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def value(self) -> int: ...
+
+class Phase(enum.IntFlag):
+    OIL = 1
+    GAS = 2
+    WATER = 4

resdata/bin.py

@@ -0,0 +1,8 @@
+import os
+import sys
+
+
+def main():
+    prog = os.path.basename(sys.argv[0])
+    path = os.path.abspath(os.path.join(os.path.dirname(__file__), prog))
+    os.execl(path, path, *sys.argv[1:])

resdata/geometry/__init__.py

@@ -0,0 +1,15 @@
+"""
+Simple package for working with 2D geometry.
+
+"""
+
+import resdata
+
+from .cpolyline import CPolyline
+from .cpolyline_collection import CPolylineCollection
+from .geo_pointset import GeoPointset
+from .geo_region import GeoRegion
+from .geometry_tools import GeometryTools
+from .polyline import Polyline
+from .surface import Surface
+from .xyz_io import XYZIo

resdata/geometry/cpolyline.pyi

@@ -0,0 +1,33 @@
+import typing
+
+__all__: list[str] = ["CPolyline"]
+
+class CPolyline:
+    def __init__(
+        self,
+        name: str | None = None,
+        init_points: typing.Iterable[tuple[float, float]] = (),
+    ) -> None: ...
+    @staticmethod
+    def createFromXYZFile(filename: str, name: str | None = None) -> CPolyline: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, index: int) -> tuple[float, float]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __add__(self, other: typing.Iterable[tuple[float, float]]) -> CPolyline: ...
+    def __radd__(self, other: typing.Iterable[tuple[float, float]]) -> CPolyline: ...
+    def __iadd__(self, other: typing.Iterable[tuple[float, float]]) -> typing.Self: ...
+    def addPoint(self, xc: float, yc: float, front: bool = False) -> None: ...
+    def getName(self) -> str | None: ...
+    def segmentIntersects(
+        self, p1: tuple[float, float], p2: tuple[float, float]
+    ) -> bool: ...
+    def intersects(self, polyline: typing.Iterable[tuple[float, float]]) -> bool: ...
+    def segmentLength(self) -> float: ...
+    def extendToBBox(
+        self, bbox: typing.Sequence[tuple[float, float]], start: bool = True
+    ) -> CPolyline: ...
+    def connect(
+        self, target: typing.Sequence[tuple[float, float]]
+    ) -> list[tuple[float, float]]: ...
+    def unzip(self) -> tuple[list[float], list[float]]: ...
+    def unzip2(self) -> tuple[list[float], list[float]]: ...

resdata/geometry/cpolyline_collection.py

@@ -0,0 +1,78 @@
+"""
+Create a polygon
+"""
+
+import resdata.geometry._cpolyline_collection as _cpolyline_collection
+from resdata._base_c_class import _BaseCClass
+from resdata.geometry import CPolyline
+
+
+class CPolylineCollection(_BaseCClass):
+    TYPE_NAME = "rd_geo_polygon_collection"
+
+    def __init__(self):
+        c_ptr = _cpolyline_collection._alloc_new()
+        super().__init__(c_ptr)
+
+    def __contains__(self, name):
+        return _cpolyline_collection._has_polyline(self, name)
+
+    def __len__(self):
+        return _cpolyline_collection._size(self)
+
+    def __iter__(self):
+        index = 0
+
+        while index < len(self):
+            yield self[index]
+            index += 1
+
+    def __getitem__(self, index):
+        if isinstance(index, int):
+            if index < 0:
+                index += len(self)
+
+            if 0 <= index < len(self):
+                return _cpolyline_collection._iget(self, index)
+            else:
+                raise IndexError(
+                    "Invalid index:%d - valid range: [0,%d)" % (index, len(self))
+                )
+        elif isinstance(index, str):
+            if index in self:
+                return _cpolyline_collection._get(self, index)
+            else:
+                raise KeyError("No polyline named:%s" % index)
+        else:
+            raise TypeError("The index argument must be string or integer")
+
+    def shallowCopy(self):
+        copy = CPolylineCollection()
+        for pl in self:
+            _cpolyline_collection._add_polyline(copy, pl)
+
+        return copy
+
+    def addPolyline(self, polyline, name=None):
+        if not isinstance(polyline, CPolyline):
+            polyline = CPolyline(init_points=polyline, name=name)
+        else:
+            if name is not None:
+                raise ValueError(
+                    "The name keyword argument can only be supplied when add not CPOlyline object"
+                )
+
+        name = polyline.getName()
+        if name and name in self:
+            raise KeyError("The polyline collection already has an object:%s" % name)
+
+        _cpolyline_collection._add_polyline(self, polyline)
+
+    def createPolyline(self, name=None):
+        if name and name in self:
+            raise KeyError("The polyline collection already has an object:%s" % name)
+
+        return _cpolyline_collection._create_polyline(self, name)
+
+    def free(self):
+        _cpolyline_collection._free(self)

resdata/geometry/geo_pointset.py

@@ -0,0 +1,48 @@
+import resdata.geometry._geo_pointset as _geo_pointset
+from resdata._base_c_class import _BaseCClass
+
+
+class GeoPointset(_BaseCClass):
+    TYPE_NAME = "rd_geo_points"
+
+    def __init__(self, external_z=False):
+        c_ptr = _geo_pointset._alloc(external_z)
+        if c_ptr is not None:
+            super().__init__(c_ptr)
+        else:
+            ext = "external" if external_z else "internal"
+            raise ValueError("Failed to construct GeoPointset with %s_z." % ext)
+
+    @staticmethod
+    def fromSurface(surface):
+        return surface.getPointset()
+
+    def __eq__(self, other):
+        if isinstance(other, GeoPointset):
+            return _geo_pointset._equal(self, other)
+        return NotImplemented
+
+    def __getitem__(self, key):
+        size = len(self)
+        if isinstance(key, int):
+            idx = key
+            if idx < 0:
+                idx += size
+            if 0 <= idx < size:
+                return _geo_pointset._iget_z(self, idx)
+            else:
+                raise IndexError(
+                    "Invalid index, must be in [0, %d), was: %d." % (size, key)
+                )
+        else:
+            # TODO implement slicing?
+            raise ValueError("Index must be int, not %s." % type(key))
+
+    def __len__(self):
+        return _geo_pointset._get_size(self)
+
+    def __repr__(self):
+        return self._create_repr("len=%d" % len(self))
+
+    def free(self):
+        _geo_pointset._free(self)

resdata/geometry/geo_region.py

@@ -0,0 +1,88 @@
+import resdata.geometry._geo_region as _geo_region
+from resdata._base_c_class import _BaseCClass
+
+from .cpolyline import CPolyline
+
+
+class GeoRegion(_BaseCClass):
+    TYPE_NAME = "rd_geo_region"
+
+    def __init__(self, pointset, preselect=False):
+        self._preselect = True if preselect else False
+        c_ptr = _geo_region._alloc(pointset, self._preselect)
+        if c_ptr is not None:
+            super().__init__(c_ptr)
+            # The C geo_region only borrows the pointset, so we must keep a
+            # reference to it (and, transitively, whatever owns its memory)
+            # alive for as long as the region exists.
+            self._pointset = pointset
+        else:
+            raise ValueError(
+                "Could not construct GeoRegion from pointset %s." % pointset
+            )
+
+    def getActiveList(self) -> list[int]:
+        return _geo_region._get_index_list(self)
+
+    def _assert_polygon(self, polygon):
+        if not isinstance(polygon, CPolyline):
+            raise ValueError("Need to select with a CPolyline, not %s." % type(polygon))
+
+    def _construct_cline(self, line):
+        """Takes a line ((x1,y1), (x2,y2)) and returns them
+        reordered to (x1x2, y1y2).
+        """
+        try:
+            p1, p2 = line
+            x1, y1 = map(float, p1)
+            x2, y2 = map(float, p2)
+        except Exception as err:
+            err_msg = "Select with pair ((x1,y1), (x2,y2)), not %s (%s)."
+            raise ValueError(err_msg % (line, err))
+        return (x1, x2), (y1, y2)
+
+    def select_inside(self, polygon):
+        self._assert_polygon(polygon)
+        _geo_region._select_inside_polygon(self, polygon)
+
+    def select_outside(self, polygon):
+        self._assert_polygon(polygon)
+        _geo_region._select_outside_polygon(self, polygon)
+
+    def deselect_inside(self, polygon):
+        self._assert_polygon(polygon)
+        _geo_region._deselect_inside_polygon(self, polygon)
+
+    def deselect_outside(self, polygon):
+        self._assert_polygon(polygon)
+        _geo_region._deselect_outside_polygon(self, polygon)
+
+    def select_above(self, line):
+        x_ptr, y_ptr = self._construct_cline(line)
+        _geo_region._select_above_line(self, x_ptr, y_ptr)
+
+    def select_below(self, line):
+        x_ptr, y_ptr = self._construct_cline(line)
+        _geo_region._select_below_line(self, x_ptr, y_ptr)
+
+    def deselect_above(self, line):
+        x_ptr, y_ptr = self._construct_cline(line)
+        _geo_region._deselect_above_line(self, x_ptr, y_ptr)
+
+    def deselect_below(self, line):
+        x_ptr, y_ptr = self._construct_cline(line)
+        _geo_region._deselect_below_line(self, x_ptr, y_ptr)
+
+    def __len__(self):
+        """Returns the size of the active list, not the size of the
+        underlying pointset"""
+        return _geo_region._len(self)
+
+    def __repr__(self):
+        ls = len(self)
+        il = repr(self.getActiveList())
+        pres = "preselected" if self._preselect else "not preselected"
+        return self._create_repr("size=%d, active_list=<%s>, %s" % (ls, il, pres))
+
+    def free(self):
+        _geo_region._free(self)