subsurface-terra 2025.1.0rc14__py3-none-any.whl → 2025.1.0rc16__py3-none-any.whl

subsurface/core/reader_helpers/readers_data.py

@@ -1,131 +1,131 @@
-import enum
-import pathlib
-import pandas as pd
-
-from subsurface.core.utils.utils_core import get_extension
-from pydantic import BaseModel, Field, model_validator
-from typing import Union, List, Optional
-
-if pd.__version__ < '1.4.0':
-    pass
-elif pd.__version__ >= '1.4.0':
-    from pandas._typing import FilePath, ReadCsvBuffer
-
-    fb = Union[FilePath, ReadCsvBuffer[bytes], ReadCsvBuffer[str]]
-
-
-class SupportedFormats(str, enum.Enum):
-    DXF = "dxf"
-    DXFStream = "dxfstream"
-    CSV = "csv"
-    JSON = "json"
-    XLXS = "xlsx"
-
-
-class GenericReaderFilesHelper(BaseModel):
-    file_or_buffer: Union[str, bytes, pathlib.Path, dict]
-    usecols: Optional[Union[List[str], List[int]]] = None
-    col_names: Optional[List[Union[str, int]]] = None
-    drop_cols: Optional[List[str]] = None
-    format: Optional[SupportedFormats] = None
-    separator: Optional[str] = None
-    index_map: Optional[dict] = None  # Adjusted for serialization
-    columns_map: Optional[dict] = None  # Adjusted for serialization
-    additional_reader_kwargs: dict = Field(default_factory=dict)
-    encoding: str = "ISO-8859-1"
-    index_col: Optional[Union[int, str, bool]] = False
-    header: Union[None, int, List[int]] = 0
-
-    # Computed fields
-    file_or_buffer_type: str = Field(init=False)
-
-    @model_validator(mode="before")
-    def set_format_and_file_type(cls, values):
-        file_or_buffer = values.get('file_or_buffer')
-        format = values.get('format')
-
-        # Determine format if not provided
-        if format is None and file_or_buffer is not None:
-            extension = get_extension(file_or_buffer)
-            format_map = {
-                    ".dxf" : SupportedFormats.DXF,
-                    ".csv" : SupportedFormats.CSV,
-                    ".json": SupportedFormats.JSON,
-                    ".xlsx": SupportedFormats.XLXS,
-            }
-            format = format_map.get(extension.lower())
-            values['format'] = format
-
-        # Set file_or_buffer_type as a string representation
-        if file_or_buffer is not None:
-            values['file_or_buffer_type'] = type(file_or_buffer).__name__
-        else:
-            values['file_or_buffer_type'] = None
-
-        return values
-
-        # Custom validation for index_col to explicitly handle None
-
-    @model_validator(mode="before")
-    def validate_additional_reader_kwargs(cls, values):
-        additional_reader_kwargs = values.get('additional_reader_kwargs')
-        # Make sure that if any of the values is a regex expression that it is properly parsed like "delimiter":"\\\\s{2,}" to delimiter="\s{2,}"
-        if additional_reader_kwargs is not None:
-            for key, value in additional_reader_kwargs.items():
-                if isinstance(value, str):
-                    additional_reader_kwargs[key] = value.replace("\\\\", "\\")
-        
-        return values
-    
-    
-    @model_validator(mode="before")
-    def validate_index_col(cls, values):
-        index_col = values.get('index_col')
-        # Allow None explicitly
-        if index_col is None:
-            values['index_col'] = False
-        else:
-            # Ensure index_col is either int, str, or bool
-            if not isinstance(index_col, (int, str, bool)):
-                raise ValueError(f"Invalid value for index_col: {index_col}. Must be int, str, bool, or None.")
-
-        return values
-
-    # Validator to handle negative header values. If -1 is the same as null, other raise an error
-    @model_validator(mode="before")
-    def validate_header(cls, values):
-        header = values.get('header')
-        if header == -1:
-            values['header'] = None
-            header = None
-        if header is not None and header < 0:
-            raise ValueError(f"Invalid value for header: {header}. Must be None, 0, or positive integer.")
-        return values
-    
-    # If col names is null or empy list it should be None
-    @model_validator(mode="before")
-    def validate_col_names(cls, values):
-        col_names = values.get('col_names')
-        if col_names is None or col_names == []:
-            values['col_names'] = None
-        return values
-
-    @property
-    def pandas_reader_kwargs(self):
-        attr_dict = {
-                "names"    : self.col_names,
-                "header"   : self.header,
-                "index_col": self.index_col,
-                "usecols"  : self.usecols,
-                "encoding" : self.encoding
-        }
-        # Check if delimiter or separator is in additional_reader_kwargs if not add it here
-        if self.additional_reader_kwargs:
-            delimiter = self.additional_reader_kwargs.get("delimiter", None)
-        else:
-            delimiter = None
-        if self.separator is not None and delimiter is None:
-            attr_dict["sep"] = self.separator
-        
-        return {**attr_dict, **self.additional_reader_kwargs}
+import enum
+import pathlib
+import pandas as pd
+
+from subsurface.core.utils.utils_core import get_extension
+from pydantic import BaseModel, Field, model_validator
+from typing import Union, List, Optional
+
+if pd.__version__ < '1.4.0':
+    pass
+elif pd.__version__ >= '1.4.0':
+    from pandas._typing import FilePath, ReadCsvBuffer
+
+    fb = Union[FilePath, ReadCsvBuffer[bytes], ReadCsvBuffer[str]]
+
+
+class SupportedFormats(str, enum.Enum):
+    DXF = "dxf"
+    DXFStream = "dxfstream"
+    CSV = "csv"
+    JSON = "json"
+    XLXS = "xlsx"
+
+
+class GenericReaderFilesHelper(BaseModel):
+    file_or_buffer: Union[str, bytes, pathlib.Path, dict]
+    usecols: Optional[Union[List[str], List[int]]] = None
+    col_names: Optional[List[Union[str, int]]] = None
+    drop_cols: Optional[List[str]] = None
+    format: Optional[SupportedFormats] = None
+    separator: Optional[str] = None
+    index_map: Optional[dict] = None  # Adjusted for serialization
+    columns_map: Optional[dict] = None  # Adjusted for serialization
+    additional_reader_kwargs: dict = Field(default_factory=dict)
+    encoding: str = "ISO-8859-1"
+    index_col: Optional[Union[int, str, bool]] = False
+    header: Union[None, int, List[int]] = 0
+
+    # Computed fields
+    file_or_buffer_type: str = Field(init=False)
+
+    @model_validator(mode="before")
+    def set_format_and_file_type(cls, values):
+        file_or_buffer = values.get('file_or_buffer')
+        format = values.get('format')
+
+        # Determine format if not provided
+        if format is None and file_or_buffer is not None:
+            extension = get_extension(file_or_buffer)
+            format_map = {
+                    ".dxf" : SupportedFormats.DXF,
+                    ".csv" : SupportedFormats.CSV,
+                    ".json": SupportedFormats.JSON,
+                    ".xlsx": SupportedFormats.XLXS,
+            }
+            format = format_map.get(extension.lower())
+            values['format'] = format
+
+        # Set file_or_buffer_type as a string representation
+        if file_or_buffer is not None:
+            values['file_or_buffer_type'] = type(file_or_buffer).__name__
+        else:
+            values['file_or_buffer_type'] = None
+
+        return values
+
+        # Custom validation for index_col to explicitly handle None
+
+    @model_validator(mode="before")
+    def validate_additional_reader_kwargs(cls, values):
+        additional_reader_kwargs = values.get('additional_reader_kwargs')
+        # Make sure that if any of the values is a regex expression that it is properly parsed like "delimiter":"\\\\s{2,}" to delimiter="\s{2,}"
+        if additional_reader_kwargs is not None:
+            for key, value in additional_reader_kwargs.items():
+                if isinstance(value, str):
+                    additional_reader_kwargs[key] = value.replace("\\\\", "\\")
+        
+        return values
+    
+    
+    @model_validator(mode="before")
+    def validate_index_col(cls, values):
+        index_col = values.get('index_col')
+        # Allow None explicitly
+        if index_col is None:
+            values['index_col'] = False
+        else:
+            # Ensure index_col is either int, str, or bool
+            if not isinstance(index_col, (int, str, bool)):
+                raise ValueError(f"Invalid value for index_col: {index_col}. Must be int, str, bool, or None.")
+
+        return values
+
+    # Validator to handle negative header values. If -1 is the same as null, other raise an error
+    @model_validator(mode="before")
+    def validate_header(cls, values):
+        header = values.get('header')
+        if header == -1:
+            values['header'] = None
+            header = None
+        if header is not None and header < 0:
+            raise ValueError(f"Invalid value for header: {header}. Must be None, 0, or positive integer.")
+        return values
+    
+    # If col names is null or empy list it should be None
+    @model_validator(mode="before")
+    def validate_col_names(cls, values):
+        col_names = values.get('col_names')
+        if col_names is None or col_names == []:
+            values['col_names'] = None
+        return values
+
+    @property
+    def pandas_reader_kwargs(self):
+        attr_dict = {
+                "names"    : self.col_names,
+                "header"   : self.header,
+                "index_col": self.index_col,
+                "usecols"  : self.usecols,
+                "encoding" : self.encoding
+        }
+        # Check if delimiter or separator is in additional_reader_kwargs if not add it here
+        if self.additional_reader_kwargs:
+            delimiter = self.additional_reader_kwargs.get("delimiter", None)
+        else:
+            delimiter = None
+        if self.separator is not None and delimiter is None:
+            attr_dict["sep"] = self.separator
+        
+        return {**attr_dict, **self.additional_reader_kwargs}
    

subsurface/core/reader_helpers/readers_wells.py

@@ -1,13 +1,13 @@
-from typing import List
-
-from dataclasses import dataclass
-
-from subsurface.core.reader_helpers.readers_data import GenericReaderFilesHelper
-
-
-@dataclass
-class ReaderWellsHelper:
-    reader_collars_args: GenericReaderFilesHelper
-    reader_survey_args: GenericReaderFilesHelper
-    reader_lith_args: GenericReaderFilesHelper = None
-    reader_attr_args: List[GenericReaderFilesHelper] = None
+from typing import List
+
+from dataclasses import dataclass
+
+from subsurface.core.reader_helpers.readers_data import GenericReaderFilesHelper
+
+
+@dataclass
+class ReaderWellsHelper:
+    reader_collars_args: GenericReaderFilesHelper
+    reader_survey_args: GenericReaderFilesHelper
+    reader_lith_args: GenericReaderFilesHelper = None
+    reader_attr_args: List[GenericReaderFilesHelper] = None

subsurface/core/structs/__init__.py

@@ -1,3 +1,3 @@
-from .base_structures import StructuredData, UnstructuredData
-from .unstructured_elements import PointSet, TriSurf, LineSet
-from .structured_elements import StructuredGrid
+from .base_structures import StructuredData, UnstructuredData
+from .unstructured_elements import PointSet, TriSurf, LineSet
+from .structured_elements import StructuredGrid

subsurface/core/structs/base_structures/__init__.py

@@ -1,2 +1,2 @@
-from .unstructured_data import UnstructuredData
-from .structured_data import StructuredData
+from .unstructured_data import UnstructuredData
+from .structured_data import StructuredData

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)
+