subsurface-terra 2025.1.0rc15__py3-none-any.whl → 2025.1.0rc17__py3-none-any.whl

subsurface/core/structs/base_structures/_aux.py

@@ -0,0 +1,69 @@
+import pandas as pd
+
+
+def safe_convert_to_float32(df: pd.DataFrame, error_handling: str = 'raise') -> pd.DataFrame:
+    """
+    Convert DataFrame columns to float32, handling non-convertible columns.
+
+    Args:
+        df: DataFrame to convert
+        error_handling: How to handle non-convertible columns:
+            - 'raise': Raise an error
+            - 'skip': Skip non-convertible columns
+            - 'drop': Drop non-convertible columns
+
+    Returns:
+        DataFrame with converted columns
+    """
+    convertible, non_convertible = _check_convertible_to_float32(df)
+
+    if non_convertible:
+        if error_handling == 'raise':
+            raise ValueError(
+                f"Cannot convert columns to float32: {non_convertible}. "
+                f"These columns contain non-numeric data."
+            )
+        elif error_handling == 'skip':
+            # Only convert the convertible columns
+            result = df.copy()
+            for col in convertible:
+                result[col] = df[col].astype('float32')
+            return result
+        elif error_handling == 'drop':
+            # Drop non-convertible columns
+            return df[convertible].astype('float32')
+        else:
+            raise ValueError(f"Invalid error_handling: {error_handling}")
+
+    return df.astype('float32')
+
+
+def _check_convertible_to_float32(df: pd.DataFrame) -> tuple[list[str], list[str]]:
+    """
+    Check which columns in a DataFrame can be safely converted to float32.
+
+    Returns:
+        tuple: (convertible_columns, non_convertible_columns)
+    """
+    convertible = []
+    non_convertible = []
+
+    for col in df.columns:
+        if pd.api.types.is_numeric_dtype(df[col]):
+            # Already numeric, can convert
+            convertible.append(col)
+        elif pd.api.types.is_bool_dtype(df[col]):
+            # Boolean can be converted (True->1.0, False->0.0)
+            convertible.append(col)
+        elif pd.api.types.is_string_dtype(df[col]) or pd.api.types.is_object_dtype(df[col]):
+            # Try to convert to numeric
+            try:
+                pd.to_numeric(df[col], errors='raise')
+                convertible.append(col)
+            except (ValueError, TypeError):
+                non_convertible.append(col)
+        else:
+            # Other types (datetime, timedelta, categorical, etc.)
+            non_convertible.append(col)
+
+    return convertible, non_convertible

subsurface/core/structs/base_structures/_liquid_earth_mesh.py

@@ -1,121 +1,121 @@
-import json
-import numpy as np
-import pandas as pd
-
-
-class LiquidEarthMesh:
-    def __init__(self, vertex=None, cells=None, attributes=None, points_attributes=None, data_attrs=None):
-        self.vertex = vertex  # Expected to be a numpy array of shape (N, 3)
-        self.cells = cells  # Expected to be a numpy array of shape (M, K)
-        self.attributes = attributes
-        self.points_attributes = points_attributes
-        self.data_attrs = data_attrs if data_attrs is not None else {}
-
-    def to_binary(self, order='F') -> bytes:
-        body_ = self._to_bytearray(order)
-        header_ = self._set_binary_header()
-        header_json = json.dumps(header_)
-        header_json_bytes = header_json.encode('utf-8')
-        header_json_length = len(header_json_bytes)
-        header_json_length_bytes = header_json_length.to_bytes(4, byteorder='little')
-        file = header_json_length_bytes + header_json_bytes + body_
-        return file
-
-    def _set_binary_header(self):
-        header = {
-                "vertex_shape"     : self.vertex.shape if self.vertex is not None else [0, 0],
-                "cell_shape"       : self.cells.shape if self.cells is not None else [0, 0],
-                "cell_attr_shape"  : self.attributes.shape if not self.attributes.empty else [0, 0],
-                "vertex_attr_shape": self.points_attributes.shape if not self.points_attributes.empty else [0, 0],
-                "cell_attr_names"  : self.attributes.columns.tolist() if not self.attributes.empty else [],
-                "cell_attr_types"  : self.attributes.dtypes.astype(str).tolist() if not self.attributes.empty else [],
-                "vertex_attr_names": self.points_attributes.columns.tolist() if not self.points_attributes.empty else [],
-                "vertex_attr_types": self.points_attributes.dtypes.astype(str).tolist() if not self.points_attributes.empty else [],
-                "xarray_attrs"     : self.data_attrs
-        }
-        return header
-
-    def _to_bytearray(self, order):
-        parts = []
-        if self.vertex is not None:
-            vertex_bytes = self.vertex.astype('float32').tobytes(order)
-            parts.append(vertex_bytes)
-        if self.cells is not None:
-            cells_bytes = self.cells.astype('int32').tobytes(order)
-            parts.append(cells_bytes)
-        if not self.attributes.empty:
-            cell_attr_bytes = self.attributes.values.astype('float32').tobytes(order)
-            parts.append(cell_attr_bytes)
-        if not self.points_attributes.empty:
-            vertex_attr_bytes = self.points_attributes.values.astype('float32').tobytes(order)
-            parts.append(vertex_attr_bytes)
-        bytearray_le = b''.join(parts)
-        return bytearray_le
-
-    @classmethod
-    def from_binary(cls, binary_data, order='F'):
-        # Read header length
-        header_length_bytes = binary_data[:4]
-        header_length = int.from_bytes(header_length_bytes, byteorder='little')
-        # Read header
-        header_json_bytes = binary_data[4:4 + header_length]
-        header_json = header_json_bytes.decode('utf-8')
-        header = json.loads(header_json)
-        # Read body
-        body = binary_data[4 + header_length:]
-        offset = 0
-
-        # Parse vertices
-        vertex_shape = header['vertex_shape']
-        if vertex_shape[0] > 0 and vertex_shape[1] > 0:
-            num_vertices = np.prod(vertex_shape)
-            num_bytes = num_vertices * 4  # float32
-            vertex = np.frombuffer(body[offset:offset + num_bytes], dtype=np.float32, count=num_vertices)
-            offset += num_bytes
-            vertex = vertex.reshape(vertex_shape, order=order)
-        else:
-            vertex = None
-
-        # Parse cells
-        cell_shape = header['cell_shape']
-        if cell_shape[0] > 0 and cell_shape[1] > 0:
-            num_cells = np.prod(cell_shape)
-            num_bytes = num_cells * 4  # int32
-            cells = np.frombuffer(body[offset:offset + num_bytes], dtype=np.int32, count=num_cells)
-            offset += num_bytes
-            cells = cells.reshape(cell_shape, order=order)
-        else:
-            cells = None
-
-        # Parse cell attributes
-        attributes = pd.DataFrame()
-        cell_attr_shape = header['cell_attr_shape']
-        if cell_attr_shape[0] > 0 and cell_attr_shape[1] > 0:
-            num_attrs = np.prod(cell_attr_shape)
-            num_bytes = num_attrs * 4  # float32
-            cell_attr_values = np.frombuffer(body[offset:offset + num_bytes], dtype=np.float32, count=num_attrs)
-            offset += num_bytes
-            cell_attr_values = cell_attr_values.reshape(cell_attr_shape, order=order)
-            attr_names = header['cell_attr_names']
-            attributes = pd.DataFrame(cell_attr_values, columns=attr_names)
-        else:
-            attributes = None
-
-        # Parse vertex attributes
-        points_attributes = pd.DataFrame()
-        vertex_attr_shape = header['vertex_attr_shape']
-        if vertex_attr_shape[0] > 0 and vertex_attr_shape[1] > 0:
-            num_attrs = np.prod(vertex_attr_shape)
-            num_bytes = num_attrs * 4  # float32
-            vertex_attr_values = np.frombuffer(body[offset:offset + num_bytes], dtype=np.float32, count=num_attrs)
-            offset += num_bytes
-            vertex_attr_values = vertex_attr_values.reshape(vertex_attr_shape, order=order)
-            attr_names = header['vertex_attr_names']
-            points_attributes = pd.DataFrame(vertex_attr_values, columns=attr_names)
-        else:
-            points_attributes = None
-
-        data_attrs = header.get('xarray_attrs', {})
-
-        return cls(vertex=vertex, cells=cells, attributes=attributes, points_attributes=points_attributes, data_attrs=data_attrs)
-
+import json
+import numpy as np
+import pandas as pd
+
+
+class LiquidEarthMesh:
+    def __init__(self, vertex=None, cells=None, attributes=None, points_attributes=None, data_attrs=None):
+        self.vertex = vertex  # Expected to be a numpy array of shape (N, 3)
+        self.cells = cells  # Expected to be a numpy array of shape (M, K)
+        self.attributes = attributes
+        self.points_attributes = points_attributes
+        self.data_attrs = data_attrs if data_attrs is not None else {}
+
+    def to_binary(self, order='F') -> bytes:
+        body_ = self._to_bytearray(order)
+        header_ = self._set_binary_header()
+        header_json = json.dumps(header_)
+        header_json_bytes = header_json.encode('utf-8')
+        header_json_length = len(header_json_bytes)
+        header_json_length_bytes = header_json_length.to_bytes(4, byteorder='little')
+        file = header_json_length_bytes + header_json_bytes + body_
+        return file
+
+    def _set_binary_header(self):
+        header = {
+                "vertex_shape"     : self.vertex.shape if self.vertex is not None else [0, 0],
+                "cell_shape"       : self.cells.shape if self.cells is not None else [0, 0],
+                "cell_attr_shape"  : self.attributes.shape if not self.attributes.empty else [0, 0],
+                "vertex_attr_shape": self.points_attributes.shape if not self.points_attributes.empty else [0, 0],
+                "cell_attr_names"  : self.attributes.columns.tolist() if not self.attributes.empty else [],
+                "cell_attr_types"  : self.attributes.dtypes.astype(str).tolist() if not self.attributes.empty else [],
+                "vertex_attr_names": self.points_attributes.columns.tolist() if not self.points_attributes.empty else [],
+                "vertex_attr_types": self.points_attributes.dtypes.astype(str).tolist() if not self.points_attributes.empty else [],
+                "xarray_attrs"     : self.data_attrs
+        }
+        return header
+
+    def _to_bytearray(self, order):
+        parts = []
+        if self.vertex is not None:
+            vertex_bytes = self.vertex.astype('float32').tobytes(order)
+            parts.append(vertex_bytes)
+        if self.cells is not None:
+            cells_bytes = self.cells.astype('int32').tobytes(order)
+            parts.append(cells_bytes)
+        if not self.attributes.empty:
+            cell_attr_bytes = self.attributes.values.astype('float32').tobytes(order)
+            parts.append(cell_attr_bytes)
+        if not self.points_attributes.empty:
+            vertex_attr_bytes = self.points_attributes.values.astype('float32').tobytes(order)
+            parts.append(vertex_attr_bytes)
+        bytearray_le = b''.join(parts)
+        return bytearray_le
+
+    @classmethod
+    def from_binary(cls, binary_data, order='F'):
+        # Read header length
+        header_length_bytes = binary_data[:4]
+        header_length = int.from_bytes(header_length_bytes, byteorder='little')
+        # Read header
+        header_json_bytes = binary_data[4:4 + header_length]
+        header_json = header_json_bytes.decode('utf-8')
+        header = json.loads(header_json)
+        # Read body
+        body = binary_data[4 + header_length:]
+        offset = 0
+
+        # Parse vertices
+        vertex_shape = header['vertex_shape']
+        if vertex_shape[0] > 0 and vertex_shape[1] > 0:
+            num_vertices = np.prod(vertex_shape)
+            num_bytes = num_vertices * 4  # float32
+            vertex = np.frombuffer(body[offset:offset + num_bytes], dtype=np.float32, count=num_vertices)
+            offset += num_bytes
+            vertex = vertex.reshape(vertex_shape, order=order)
+        else:
+            vertex = None
+
+        # Parse cells
+        cell_shape = header['cell_shape']
+        if cell_shape[0] > 0 and cell_shape[1] > 0:
+            num_cells = np.prod(cell_shape)
+            num_bytes = num_cells * 4  # int32
+            cells = np.frombuffer(body[offset:offset + num_bytes], dtype=np.int32, count=num_cells)
+            offset += num_bytes
+            cells = cells.reshape(cell_shape, order=order)
+        else:
+            cells = None
+
+        # Parse cell attributes
+        attributes = pd.DataFrame()
+        cell_attr_shape = header['cell_attr_shape']
+        if cell_attr_shape[0] > 0 and cell_attr_shape[1] > 0:
+            num_attrs = np.prod(cell_attr_shape)
+            num_bytes = num_attrs * 4  # float32
+            cell_attr_values = np.frombuffer(body[offset:offset + num_bytes], dtype=np.float32, count=num_attrs)
+            offset += num_bytes
+            cell_attr_values = cell_attr_values.reshape(cell_attr_shape, order=order)
+            attr_names = header['cell_attr_names']
+            attributes = pd.DataFrame(cell_attr_values, columns=attr_names)
+        else:
+            attributes = None
+
+        # Parse vertex attributes
+        points_attributes = pd.DataFrame()
+        vertex_attr_shape = header['vertex_attr_shape']
+        if vertex_attr_shape[0] > 0 and vertex_attr_shape[1] > 0:
+            num_attrs = np.prod(vertex_attr_shape)
+            num_bytes = num_attrs * 4  # float32
+            vertex_attr_values = np.frombuffer(body[offset:offset + num_bytes], dtype=np.float32, count=num_attrs)
+            offset += num_bytes
+            vertex_attr_values = vertex_attr_values.reshape(vertex_attr_shape, order=order)
+            attr_names = header['vertex_attr_names']
+            points_attributes = pd.DataFrame(vertex_attr_values, columns=attr_names)
+        else:
+            points_attributes = None
+
+        data_attrs = header.get('xarray_attrs', {})
+
+        return cls(vertex=vertex, cells=cells, attributes=attributes, points_attributes=points_attributes, data_attrs=data_attrs)
+

subsurface/core/structs/base_structures/_unstructured_data_constructor.py

@@ -1,70 +1,70 @@
-from typing import Union, Dict, Literal, List
-
-import numpy as np
-import pandas as pd
-import xarray as xr
-
-from subsurface.core.structs.base_structures.base_structures_enum import SpecialCellCase
-
-
-def vertex_and_cells_arrays_to_data_array(cells: Union[np.ndarray, Literal["lines", "points"], SpecialCellCase],
-                                          vertex: np.ndarray):
-    n_vertex = vertex.shape[0]
-    if type(cells) is not np.ndarray:
-        cells: np.ndarray = _create_default_cells_arg(
-            cells=cells,
-            n_vertex=n_vertex
-        )
-    n_cells = cells.shape[0]
-
-    vertex_data_array = xr.DataArray(
-        data=vertex,
-        dims=['points', 'XYZ'],
-        coords={'XYZ': ['X', 'Y', 'Z']}
-    )
-    cells_data_array = xr.DataArray(cells, dims=['cell', 'nodes'])
-    return cells_data_array, n_cells, n_vertex, vertex_data_array
-
-
-def raw_attributes_to_dict_data_arrays(
-        default_attributes_name: str, n_items: int, dims: List[str],
-        raw_attributes: Union[None, pd.DataFrame, Dict[str, xr.DataArray]]) \
-        -> Dict[str, xr.DataArray]:
-    
-    if raw_attributes is None or type(raw_attributes) is pd.DataFrame:
-        points_attributes_xarray_dict = {
-                default_attributes_name: _data_array_attributes_from_raw_data(
-                    raw_data=raw_attributes,
-                    dims=dims,
-                    n_rows=n_items
-                )
-        }
-    else:
-        points_attributes_xarray_dict = raw_attributes
-    return points_attributes_xarray_dict
-
-
-def _create_default_cells_arg(cells: Union[Literal["points", "lines"], SpecialCellCase],
-                              n_vertex: int) -> np.ndarray:
-    if cells is None or cells == 'points' or cells == SpecialCellCase.POINTS:
-        cells_array = np.arange(0, n_vertex).reshape(-1, 1)
-    elif cells == 'lines' or cells == SpecialCellCase.LINES:
-        a = np.arange(0, n_vertex - 1, dtype=np.int_)
-        b = np.arange(1, n_vertex, dtype=np.int_)
-        cells_array = np.vstack([a, b]).T
-    else:
-        raise ValueError("cells must be either None (will default to 'points'),"
-                         "'points', 'lines' or a 2D ndarray.")
-    return cells_array
-
-
-def _data_array_attributes_from_raw_data(raw_data: Union[None, pd.DataFrame],
-                                         dims: List[str], n_rows: int) -> xr.DataArray:
-    if raw_data is None:
-        raw_data = pd.DataFrame(np.zeros((n_rows, 0)))
-
-    if type(raw_data) is pd.DataFrame:
-        data_array = xr.DataArray(raw_data, dims=dims)
-    else:
-        raise ValueError("cells_attributes must be either pd.DataFrame or " "None/default.")
-    return data_array
+from typing import Union, Dict, Literal, List
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+from subsurface.core.structs.base_structures.base_structures_enum import SpecialCellCase
+
+
+def vertex_and_cells_arrays_to_data_array(cells: Union[np.ndarray, Literal["lines", "points"], SpecialCellCase],
+                                          vertex: np.ndarray):
+    n_vertex = vertex.shape[0]
+    if type(cells) is not np.ndarray:
+        cells: np.ndarray = _create_default_cells_arg(
+            cells=cells,
+            n_vertex=n_vertex
+        )
+    n_cells = cells.shape[0]
+
+    vertex_data_array = xr.DataArray(
+        data=vertex,
+        dims=['points', 'XYZ'],
+        coords={'XYZ': ['X', 'Y', 'Z']}
+    )
+    cells_data_array = xr.DataArray(cells, dims=['cell', 'nodes'])
+    return cells_data_array, n_cells, n_vertex, vertex_data_array
+
+
+def raw_attributes_to_dict_data_arrays(
+        default_attributes_name: str, n_items: int, dims: List[str],
+        raw_attributes: Union[None, pd.DataFrame, Dict[str, xr.DataArray]]) \
+        -> Dict[str, xr.DataArray]:
+    
+    if raw_attributes is None or type(raw_attributes) is pd.DataFrame:
+        points_attributes_xarray_dict = {
+                default_attributes_name: _data_array_attributes_from_raw_data(
+                    raw_data=raw_attributes,
+                    dims=dims,
+                    n_rows=n_items
+                )
+        }
+    else:
+        points_attributes_xarray_dict = raw_attributes
+    return points_attributes_xarray_dict
+
+
+def _create_default_cells_arg(cells: Union[Literal["points", "lines"], SpecialCellCase],
+                              n_vertex: int) -> np.ndarray:
+    if cells is None or cells == 'points' or cells == SpecialCellCase.POINTS:
+        cells_array = np.arange(0, n_vertex).reshape(-1, 1)
+    elif cells == 'lines' or cells == SpecialCellCase.LINES:
+        a = np.arange(0, n_vertex - 1, dtype=np.int_)
+        b = np.arange(1, n_vertex, dtype=np.int_)
+        cells_array = np.vstack([a, b]).T
+    else:
+        raise ValueError("cells must be either None (will default to 'points'),"
+                         "'points', 'lines' or a 2D ndarray.")
+    return cells_array
+
+
+def _data_array_attributes_from_raw_data(raw_data: Union[None, pd.DataFrame],
+                                         dims: List[str], n_rows: int) -> xr.DataArray:
+    if raw_data is None:
+        raw_data = pd.DataFrame(np.zeros((n_rows, 0)))
+
+    if type(raw_data) is pd.DataFrame:
+        data_array = xr.DataArray(raw_data, dims=dims)
+    else:
+        raise ValueError("cells_attributes must be either pd.DataFrame or " "None/default.")
+    return data_array

subsurface/core/structs/base_structures/base_structures_enum.py

@@ -1,6 +1,6 @@
-import enum
-
-
-class SpecialCellCase(enum.Enum):
-    POINTS = "points"
-    LINES = "lines"
+import enum
+
+
+class SpecialCellCase(enum.Enum):
+    POINTS = "points"
+    LINES = "lines"