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

subsurface/core/geological_formats/boreholes/collars.py

@@ -1,27 +1,27 @@
-import pandas as pd
-from dataclasses import dataclass
-
-from ...structs.base_structures import UnstructuredData
-from ...structs.base_structures.base_structures_enum import SpecialCellCase
-from ...structs.unstructured_elements import PointSet
-
-
-@dataclass
-class Collars:
-    ids: list[str]
-    collar_loc: PointSet
-    
-    @classmethod
-    def from_df(cls, df: pd.DataFrame):
-        unstruc: UnstructuredData = UnstructuredData.from_array(
-            vertex=df[["x", "y", "z"]].values,
-            cells=SpecialCellCase.POINTS
-        )
-        return cls(
-            ids=df.index.to_list(),
-            collar_loc=PointSet(data=unstruc)
-        )
-    
-    @property
-    def data(self):
+import pandas as pd
+from dataclasses import dataclass
+
+from ...structs.base_structures import UnstructuredData
+from ...structs.base_structures.base_structures_enum import SpecialCellCase
+from ...structs.unstructured_elements import PointSet
+
+
+@dataclass
+class Collars:
+    ids: list[str]
+    collar_loc: PointSet
+    
+    @classmethod
+    def from_df(cls, df: pd.DataFrame):
+        unstruc: UnstructuredData = UnstructuredData.from_array(
+            vertex=df[["x", "y", "z"]].values,
+            cells=SpecialCellCase.POINTS
+        )
+        return cls(
+            ids=df.index.to_list(),
+            collar_loc=PointSet(data=unstruc)
+        )
+    
+    @property
+    def data(self):
         return self.collar_loc.data

subsurface/core/geological_formats/boreholes/survey.py

@@ -1,86 +1,86 @@
-from dataclasses import dataclass
-from typing import Union, Hashable, Optional
-
-import pandas as pd
-
-from ._map_attrs_to_survey import combine_survey_and_attrs
-from ._survey_to_unstruct import data_frame_to_unstructured_data
-from ...structs.base_structures import UnstructuredData
-from ...structs.unstructured_elements import LineSet
-
-NUMBER_NODES = 30
-RADIUS = 10
-
-
-@dataclass
-class Survey:
-    ids: list[str]
-    survey_trajectory: LineSet
-    well_id_mapper: dict[str, int] = None  #: This is following the order of the survey csv that can be different that the collars
-
-    @property
-    def id_to_well_id(self):
-        # Reverse the well_id_mapper dictionary to map IDs to well names
-        id_to_well_name_mapper = {v: k for k, v in self.well_id_mapper.items()}
-        return id_to_well_name_mapper
-
-    @classmethod
-    def from_df(cls, survey_df: 'pd.DataFrame', attr_df: Optional['pd.DataFrame'] = None, number_nodes: Optional[int] = NUMBER_NODES,
-                duplicate_attr_depths: bool = False) -> 'Survey':
-        """
-        Create a Survey object from two DataFrames containing survey and attribute data.
-
-        :param survey_df: DataFrame containing survey data.
-        :param attr_df: DataFrame containing attribute data. This is used to make sure the raw data is perfectly aligned.
-        :param number_nodes: Optional parameter specifying the number of nodes.
-        :return: A Survey object representing the input data.
-
-        """
-        trajectories: UnstructuredData = data_frame_to_unstructured_data(
-            survey_df=_correct_angles(survey_df),
-            attr_df=attr_df,
-            number_nodes=number_nodes,
-            duplicate_attr_depths=duplicate_attr_depths
-        )
-        # Grab the unique ids
-        unique_ids = trajectories.points_attributes["well_id"].unique()
-
-        return cls(
-            ids=unique_ids,
-            survey_trajectory=LineSet(data=trajectories, radius=RADIUS),
-            well_id_mapper=trajectories.data.attrs["well_id_mapper"]
-        )
-
-    def get_well_string_id(self, well_id: int) -> str:
-        return self.ids[well_id]
-
-    def get_well_num_id(self, well_string_id: Union[str, Hashable]) -> int:
-        return self.well_id_mapper.get(well_string_id, None)
-
-    def update_survey_with_lith(self, lith: pd.DataFrame):
-        unstruct: UnstructuredData = combine_survey_and_attrs(lith, self.survey_trajectory, self.well_id_mapper)
-        self.survey_trajectory.data = unstruct
-
-    def update_survey_with_attr(self, attrs: pd.DataFrame):
-        self.survey_trajectory.data = combine_survey_and_attrs(attrs, self.survey_trajectory, self.well_id_mapper)
-
-
-def _correct_angles(df: pd.DataFrame) -> pd.DataFrame:
-    def correct_inclination(inc: float) -> float:
-        if inc < 0:
-            inc = inc % 360  # Normalize to 0-360 range first if negative
-        if 0 <= inc <= 180:
-            # add or subtract a very small number to make sure that 0 or 180 are never possible
-            return inc + 1e-10 if inc == 0 else inc - 1e-10
-        elif 180 < inc < 360:
-            return 360 - inc  # Reflect angles greater than 180 back into the 0-180 range
-        else:
-            raise ValueError(f'Inclination value {inc} is out of the expected range of 0 to 360 degrees')
-
-    def correct_azimuth(azi: float) -> float:
-        return azi % 360  # Normalize azimuth to 0-360 range
-
-    df['inc'] = df['inc'].apply(correct_inclination)
-    df['azi'] = df['azi'].apply(correct_azimuth)
-
-    return df
+from dataclasses import dataclass
+from typing import Union, Hashable, Optional
+
+import pandas as pd
+
+from ._map_attrs_to_survey import combine_survey_and_attrs
+from ._survey_to_unstruct import data_frame_to_unstructured_data
+from ...structs.base_structures import UnstructuredData
+from ...structs.unstructured_elements import LineSet
+
+NUMBER_NODES = 30
+RADIUS = 10
+
+
+@dataclass
+class Survey:
+    ids: list[str]
+    survey_trajectory: LineSet
+    well_id_mapper: dict[str, int] = None  #: This is following the order of the survey csv that can be different that the collars
+
+    @property
+    def id_to_well_id(self):
+        # Reverse the well_id_mapper dictionary to map IDs to well names
+        id_to_well_name_mapper = {v: k for k, v in self.well_id_mapper.items()}
+        return id_to_well_name_mapper
+
+    @classmethod
+    def from_df(cls, survey_df: 'pd.DataFrame', attr_df: Optional['pd.DataFrame'] = None, number_nodes: Optional[int] = NUMBER_NODES,
+                duplicate_attr_depths: bool = False) -> 'Survey':
+        """
+        Create a Survey object from two DataFrames containing survey and attribute data.
+
+        :param survey_df: DataFrame containing survey data.
+        :param attr_df: DataFrame containing attribute data. This is used to make sure the raw data is perfectly aligned.
+        :param number_nodes: Optional parameter specifying the number of nodes.
+        :return: A Survey object representing the input data.
+
+        """
+        trajectories: UnstructuredData = data_frame_to_unstructured_data(
+            survey_df=_correct_angles(survey_df),
+            attr_df=attr_df,
+            number_nodes=number_nodes,
+            duplicate_attr_depths=duplicate_attr_depths
+        )
+        # Grab the unique ids
+        unique_ids = trajectories.points_attributes["well_id"].unique()
+
+        return cls(
+            ids=unique_ids,
+            survey_trajectory=LineSet(data=trajectories, radius=RADIUS),
+            well_id_mapper=trajectories.data.attrs["well_id_mapper"]
+        )
+
+    def get_well_string_id(self, well_id: int) -> str:
+        return self.ids[well_id]
+
+    def get_well_num_id(self, well_string_id: Union[str, Hashable]) -> int:
+        return self.well_id_mapper.get(well_string_id, None)
+
+    def update_survey_with_lith(self, lith: pd.DataFrame):
+        unstruct: UnstructuredData = combine_survey_and_attrs(lith, self.survey_trajectory, self.well_id_mapper)
+        self.survey_trajectory.data = unstruct
+
+    def update_survey_with_attr(self, attrs: pd.DataFrame):
+        self.survey_trajectory.data = combine_survey_and_attrs(attrs, self.survey_trajectory, self.well_id_mapper)
+
+
+def _correct_angles(df: pd.DataFrame) -> pd.DataFrame:
+    def correct_inclination(inc: float) -> float:
+        if inc < 0:
+            inc = inc % 360  # Normalize to 0-360 range first if negative
+        if 0 <= inc <= 180:
+            # add or subtract a very small number to make sure that 0 or 180 are never possible
+            return inc + 1e-10 if inc == 0 else inc - 1e-10
+        elif 180 < inc < 360:
+            return 360 - inc  # Reflect angles greater than 180 back into the 0-180 range
+        else:
+            raise ValueError(f'Inclination value {inc} is out of the expected range of 0 to 360 degrees')
+
+    def correct_azimuth(azi: float) -> float:
+        return azi % 360  # Normalize azimuth to 0-360 range
+
+    df['inc'] = df['inc'].apply(correct_inclination)
+    df['azi'] = df['azi'].apply(correct_azimuth)
+
+    return df

subsurface/core/geological_formats/fault.py

@@ -1,48 +1,48 @@
-import pandas as pd
-
-from subsurface import optional_requirements
-
-
-class FaultSticks:
-    def __init__(self, df: pd.DataFrame):
-        self.df = df
-
-        self.pointcloud = None
-        self.sticks = None
-
-    def __getattr__(self, attr):
-        if attr in self.__dict__:
-            return getattr(self, attr)
-        return getattr(self.df, attr)
-
-    def __getitem__(self, item):
-        return self.df[item]
-
-    def plot(self, notebook=False, color="black"):
-        if not self.pointcloud:
-            self._make_pointcloud()
-            self._make_sticks()
-
-        pv = optional_requirements.require_pyvista()   
-        p = pv.Plotter(notebook=notebook)
-        p.add_mesh(self.pointcloud, color=color)
-        for stick in self.sticks:
-            p.add_mesh(stick, color=color)
-        p.show()
-
-    def _make_pointcloud(self):
-        pv = optional_requirements.require_pyvista()
-        self.pointcloud = pv.PolyData(self.df[["X", "Y", "Z"]].values)
-
-    def _make_sticks(self):
-        pv = optional_requirements.require_pyvista()
-        lines = []
-        for stick, indices in self.df.groupby("stick id").groups.items():
-            stickdf = self.df.loc[indices]
-            for (r1, row1), (r2, row2) in zip(stickdf[:-1].iterrows(), stickdf[1:].iterrows()):
-                line = pv.Line(
-                    pointa=(row1.X, row1.Y, row1.Z),
-                    pointb=(row2.X, row2.Y, row2.Z),
-                )
-                lines.append(line)
+import pandas as pd
+
+from subsurface import optional_requirements
+
+
+class FaultSticks:
+    def __init__(self, df: pd.DataFrame):
+        self.df = df
+
+        self.pointcloud = None
+        self.sticks = None
+
+    def __getattr__(self, attr):
+        if attr in self.__dict__:
+            return getattr(self, attr)
+        return getattr(self.df, attr)
+
+    def __getitem__(self, item):
+        return self.df[item]
+
+    def plot(self, notebook=False, color="black"):
+        if not self.pointcloud:
+            self._make_pointcloud()
+            self._make_sticks()
+
+        pv = optional_requirements.require_pyvista()   
+        p = pv.Plotter(notebook=notebook)
+        p.add_mesh(self.pointcloud, color=color)
+        for stick in self.sticks:
+            p.add_mesh(stick, color=color)
+        p.show()
+
+    def _make_pointcloud(self):
+        pv = optional_requirements.require_pyvista()
+        self.pointcloud = pv.PolyData(self.df[["X", "Y", "Z"]].values)
+
+    def _make_sticks(self):
+        pv = optional_requirements.require_pyvista()
+        lines = []
+        for stick, indices in self.df.groupby("stick id").groups.items():
+            stickdf = self.df.loc[indices]
+            for (r1, row1), (r2, row2) in zip(stickdf[:-1].iterrows(), stickdf[1:].iterrows()):
+                line = pv.Line(
+                    pointa=(row1.X, row1.Y, row1.Z),
+                    pointb=(row2.X, row2.Y, row2.Z),
+                )
+                lines.append(line)
         self.sticks = lines

subsurface/core/reader_helpers/reader_unstruct.py

@@ -1,11 +1,11 @@
-from dataclasses import dataclass
-
-from subsurface.core.reader_helpers.readers_data import GenericReaderFilesHelper
-
-
-@dataclass
-class ReaderUnstructuredHelper:
-    reader_vertex_args: GenericReaderFilesHelper
-    reader_cells_args: GenericReaderFilesHelper = None
-    reader_vertex_attr_args: GenericReaderFilesHelper = None
-    reader_cells_attr_args: GenericReaderFilesHelper = None
+from dataclasses import dataclass
+
+from subsurface.core.reader_helpers.readers_data import GenericReaderFilesHelper
+
+
+@dataclass
+class ReaderUnstructuredHelper:
+    reader_vertex_args: GenericReaderFilesHelper
+    reader_cells_args: GenericReaderFilesHelper = None
+    reader_vertex_attr_args: GenericReaderFilesHelper = None
+    reader_cells_attr_args: GenericReaderFilesHelper = None

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