ResSimpy 2.5.2__tar.gz → 2.6.0__tar.gz

{ressimpy-2.5.2 → ressimpy-2.6.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: ResSimpy
-Version: 2.5.2
+Version: 2.6.0
 Summary: A Python library for working with Reservoir Simulator Models.
 License: Apache-2.0
 License-File: LICENSE.MD
 Keywords: ResSimpy,Reservoir Engineering
 Author: BP
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.10,<3.15
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -14,12 +14,16 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: System :: Filesystems
-Requires-Dist: numpy (>=1.23.4,<2)
-Requires-Dist: pandas (>=1.5.0,<2.3)
-Requires-Dist: typing-extensions (>=4.12,<5.0)
+Requires-Dist: numpy (>=2.2,<2.3) ; python_version < "3.11"
+Requires-Dist: numpy (>=2.3,<2.6) ; python_version >= "3.11"
+Requires-Dist: pandas (>=2.3,<3) ; python_version < "3.11"
+Requires-Dist: pandas (>=3.0,<3.0.4) ; python_version >= "3.11"
+Requires-Dist: typing-extensions (>=4.15,<5.0)
 Description-Content-Type: text/markdown
 
 # ResSimpy: Python API for working with Reservoir Simulator models

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/DataModelBaseClasses/Grid.py

@@ -37,6 +37,7 @@ class Grid(ABC):
     _grid_properties_loaded: bool = False
     _lgrs: LGRs
     _overs: Sequence[Over]
+    _tolpv: Optional[float]
 
     def __init__(self, assume_loaded: bool = False) -> None:
         """Initialises the Grid class."""
@@ -60,6 +61,9 @@ class Grid(ABC):
         # LGRs
         self._lgrs: LGRs = LGRs()
 
+        # TOLPV
+        self._tolpv: Optional[float] = None
+
     @property
     def range_x(self) -> int | None:
         """Returns an instance of grid dimensions.
@@ -169,13 +173,20 @@ class Grid(ABC):
         """Returns the LGR module object associated with the grid."""
         return self._lgrs
 
+    @property
+    def tolpv(self) -> Optional[float]:
+        """Returns float value for TOLPV, if grid property is not loaded."""
+        self.load_grid_properties_if_not_loaded()
+        return self._tolpv
+
+    @classmethod
     @abstractmethod
-    def load_structured_grid_file(self, structure_grid_file: File,
+    def load_structured_grid_file(cls: type[Grid], structured_grid_file: File,
                                   model_unit_system: UnitSystem, lazy_loading: bool) -> Grid:
         """Loads in a structured grid file with all grid properties, and the array functions defined with 'FUNCTION'.
 
         Args:
-            structure_grid_file(File, lazy_loading: bool):The NexusFile representation of a structured grid file for
+            structured_grid_file(File, lazy_loading: bool):The NexusFile representation of a structured grid file for
             converting into a structured grid file class.
             lazy_loading(bool): If set to True, parts of the grid will only be loaded in
              when requested via properties on the object.

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/DataModelBaseClasses/Network.py

@@ -75,7 +75,7 @@ class Network(ABC):
                                                   x.node_out == connection_name and x.name != connection_name]
 
         # Add the in connection directly referenced by the connection itself if it is missing
-        if connection_to_check.node_in != connection_name:
+        if connection_to_check.node_in is not None and connection_to_check.node_in != connection_name:
             node_in_connection = self.connections.get_by_name(name=connection_to_check.node_in)
             if node_in_connection is not None and node_in_connection not in connections_directly_before_connection:
                 connections_directly_before_connection.append(node_in_connection)
@@ -84,7 +84,7 @@ class Network(ABC):
                                                  x.node_in == connection_name and x.name != connection_name]
 
         # Add the out connection directly referenced by the connection itself if it is missing
-        if connection_to_check.node_out != connection_name:
+        if connection_to_check.node_out is not None and connection_to_check.node_out != connection_name:
             node_out_connection = self.connections.get_by_name(name=connection_to_check.node_out)
             if node_out_connection is not None and node_out_connection not in connections_directly_after_connection:
                 connections_directly_after_connection.append(node_out_connection)

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/FileOperations/File.py

@@ -274,7 +274,7 @@ class File(FileBase):
             warnings.warn(f'PermissionError when trying to access file at {full_file_path}')
         except FileNotFoundError:
             # file not found, continue without filling out that information
-            warnings.warn(f'FileNotFoundError when trying to access file at {full_file_path}')
+            warnings.warn(f'No file found for: {full_file_path}')
         except KeyError:
             # Group or owner doesn't exist on this system, continue without filling out that information
             warnings.warn(f'Unable to find the group for the file at {full_file_path}')
@@ -345,6 +345,19 @@ class File(FileBase):
                                               last_modified=None)
             warnings.warn(UserWarning(f'No file found for: {full_file_path} while loading {origin}'))
             return nexus_file_class
+        except PermissionError:
+            # handle if a file can't be accessed
+            nexus_file_class = simulator_type(location=file_path,
+                                              include_locations=None,
+                                              origin=origin,
+                                              rootdir=rootdir,
+                                              include_objects=None,
+                                              file_content_as_list=None,
+                                              linked_user=None,
+                                              last_modified=None)
+            warnings.warn(UserWarning(
+                f'PermissionError when trying to access file at {full_file_path} while loading {origin}'))
+            return nexus_file_class
 
         # check last modified and user for the file
         user = File.get_pathlib_path_details(full_file_path)
@@ -403,8 +416,8 @@ class File(FileBase):
             if skip_arrays:
                 try:
                     inc_file_as_list = fo.load_file_as_list(inc_full_path)
-                except FileNotFoundError:
-                    # handle files not found - this is handled in an exception in the main loop
+                except (FileNotFoundError, PermissionError):
+                    # handle files not found or not accessible - this is handled in an exception in the main loop
                     pass
                 else:
                     all_numeric = False

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/FileOperations/file_operations.py

@@ -726,17 +726,19 @@ def split_lines_for_long_string(long_string: str, max_length: int, comment_chara
     return compiled_string
 
 
-def split_list_of_strings_by_length(list_of_strings: list[str], max_length: int) -> list[str]:
+def split_list_of_strings_by_length(list_of_strings: list[str], max_length: int,
+                                    comment_characters: None | list[str] = None) -> list[str]:
     """Splits a list of strings into a new list of strings with a maximum length.
 
     Args:
         list_of_strings (list[str]): The list of strings to be split.
         max_length (int): The maximum length of each string in the new list.
+        comment_characters (Optional[list[str]]): The comment characters to filter out. Defaults to None
 
     Returns:
         list[str]: A new list of strings split from the original list.
     """
-    return [split_lines_for_long_string(string, max_length) for string in list_of_strings]
+    return [split_lines_for_long_string(string, max_length, comment_characters) for string in list_of_strings]
 
 
 def get_full_file_path(file_path: str, origin: str, rootdir: Optional[str] = None, is_nexus: bool = True) -> str:
@@ -804,14 +806,20 @@ def split_file_as_list_by_date(file_as_list: list[str], date_token: str = 'TIME'
         of that token.
     """
     split_file: dict[str, list[str]] = {}
-    current_token_value = None
+    date_token_value = None
+    no_token_dict_key = f'BEFORE_FIRST_{date_token}'
+
     for i, line in enumerate(file_as_list):
         if check_token(date_token, line, comment_characters=comment_characters):
             # TODO handle 3 part dates in this bit
-            current_token_value = get_expected_token_value(token=date_token, token_line=line,
-                                                           file_list=file_as_list[i:],
-                                                           comment_characters=comment_characters)
-            split_file[current_token_value] = [line]
-        elif current_token_value is not None:
-            split_file[current_token_value].append(line)
+            date_token_value = get_expected_token_value(token=date_token, token_line=line,
+                                                        file_list=file_as_list[i:],
+                                                        comment_characters=comment_characters)
+            split_file[date_token_value] = [line]
+        elif date_token_value is None:
+            if no_token_dict_key not in split_file:
+                split_file[no_token_dict_key] = []
+            split_file[no_token_dict_key].append(line)
+        elif date_token_value is not None:
+            split_file[date_token_value].append(line)
     return split_file

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/Nexus/DataModels/Network/NexusActivationChange.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import Optional
 
 from ResSimpy.DataModelBaseClasses.NetworkObject import NetworkObject
+from ResSimpy.Enums.UnitsEnum import UnitSystem
 from ResSimpy.Nexus.NexusEnums.ActivationChangeEnum import ActivationChangeEnum
 from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
 from ResSimpy.Units.AttributeMappings.BaseUnitMapping import BaseUnitMapping
@@ -27,7 +28,8 @@ class NexusActivationChange(NetworkObject):
         """
         self.change = change
         self.is_constraint_change = is_constraint_change
-        super().__init__(date_format=date_format, start_date=start_date, name=name, date=date)
+        super().__init__(date_format=date_format, start_date=start_date, name=name, date=date,
+                         unit_system=UnitSystem.METRIC)
 
     @staticmethod
     def get_keyword_mapping() -> dict[str, tuple[str, type]]:

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/Nexus/DataModels/Network/NexusProc.py

@@ -1,6 +1,11 @@
 from dataclasses import dataclass
-from typing import Optional, Mapping
+from typing import Optional
+
+from ResSimpy.DataModelBaseClasses.NetworkObject import NetworkObject
+from ResSimpy.Enums.UnitsEnum import UnitSystem
+from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
 from ResSimpy.Nexus.NexusKeywords.proc_keywords import PREDEFINED_VARS, CONDITIONAL_KEYWORDS, NEXUS_ALL_PROC_FUNCS
+from ResSimpy.Units.AttributeMappings.BaseUnitMapping import BaseUnitMapping
 
 
 # set custom error message
@@ -9,18 +14,15 @@ class SetError(Exception):
 
 
 @dataclass(kw_only=True, repr=True)
-class NexusProc:
+class NexusProc(NetworkObject):
     """Class that represents a single nexus procedure."""
-    __date: Optional[str]
-    __name: Optional[str]
     __priority: Optional[int]
     __contents: Optional[list[str]]
     __contents_breakdown: dict[str, int]
 
-    def __init__(self, date: Optional[str] = None,
-                 contents: Optional[list[str]] = None,
-                 name: Optional[str] = None,
-                 priority: Optional[int] = None) -> None:
+    def __init__(self, date: Optional[str] = None, contents: Optional[list[str]] = None,
+                 name: Optional[str] = None, priority: Optional[int] = None, unit_system: Optional[UnitSystem] = None,
+                 start_date: Optional[str] = None, date_format: Optional[DateFormat] = None) -> None:
         """Initialize the attributes of the class.
 
         Attributes:
@@ -33,33 +35,23 @@ class NexusProc:
         Methods:
                 reset_nexus_proc_function_counts(): Returns a dictionary of zero counts for the nexus proc functions.
         """
-
-        self.__date = date
-        self.__name = name
         self.__priority = priority
         self.__contents = contents
+
         self.__contents_breakdown = self.reset_nexus_proc_function_counts()
+        super().__init__(properties_dict={}, date=date, date_format=date_format, start_date=start_date,
+                         unit_system=unit_system, name=name)
 
     @property
     def contents(self) -> Optional[list[str]]:
         """Returns the contents of the main body of the procedure."""
         return self.__contents
 
-    @property
-    def date(self) -> Optional[str]:
-        """Returns the date that the procedure occurred."""
-        return self.__date
-
     @property
     def priority(self) -> Optional[int]:
         """Returns the priority of the procedure."""
         return self.__priority
 
-    @property
-    def name(self) -> Optional[str]:
-        """Returns the name of the procedure."""
-        return self.__name
-
     @property
     def contents_breakdown(self) -> dict[str, int]:
         """Returns the dictionary counts of the proc functions."""
@@ -76,9 +68,9 @@ class NexusProc:
                            'Nexus Keyword Manual page 1013.')
 
     @staticmethod
-    def get_keyword_mapping() -> Mapping[str, tuple[str, type]]:
+    def get_keyword_mapping() -> dict[str, tuple[str, type]]:
         """Gets the mapping of nexus keywords to attribute definitions."""
-        keywords = {
+        keywords: dict[str, tuple[str, type]] = {
             'NAME': ('name', str),
             'PRIORITY': ('priority', str)
         }
@@ -99,3 +91,21 @@ class NexusProc:
         to_search = predef_vars | cond | all_proc_funcs
 
         return to_search
+
+    def to_string(self) -> str:
+        """Outputs the procedure as a string in the format it would be written in a Nexus file."""
+        output_str = "PROCS"
+        if self.name is not None:
+            output_str += f" NAME {self.name}"
+        if self.priority is not None:
+            output_str += f" PRIORITY {self.priority}"
+        output_str += '\n'
+        if self.contents is not None:
+            output_str += '\n'.join(self.contents) + '\n'
+        output_str += "ENDPROCS\n"
+        return output_str
+
+    @property
+    def units(self) -> BaseUnitMapping:
+        """Returns the attribute to unit map for the data object."""
+        return BaseUnitMapping(None)

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/Nexus/DataModels/Network/NexusProcs.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from typing import Sequence, TYPE_CHECKING
 
 from ResSimpy.Nexus.DataModels.Network.NexusProc import NexusProc
+from ResSimpy.Time.ISODateTime import ISODateTime
 
 if TYPE_CHECKING:
     from ResSimpy.Nexus.NexusNetwork import NexusNetwork
@@ -35,3 +36,11 @@ class NexusProcs:
     def _add_to_memory(self, procs_to_add: list[NexusProc]) -> None:
         """Adds the list of Nexus procedure objects to memory."""
         self.__procs.extend(procs_to_add)
+
+    def to_string_for_date(self, date: ISODateTime) -> str:
+        """Outputs the procedures for a specific date."""
+        output_str = ''
+        procs_for_date = [x for x in self.__procs if x.iso_date == date]
+        for proc in procs_for_date:
+            output_str += proc.to_string()
+        return output_str

ressimpy-2.6.0/ResSimpy/Nexus/DataModels/Network/NexusStreamTracer.py

@@ -0,0 +1,89 @@
+"""Class representing a single Nexus STREAM_TRACER entry."""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+from ResSimpy.DataModelBaseClasses.DataObjectMixin import DataObjectMixinDictType
+from ResSimpy.Enums.UnitsEnum import UnitSystem
+from ResSimpy.Nexus.NexusEnums.DateFormatEnum import DateFormat
+from ResSimpy.DataModelBaseClasses.NetworkObject import NetworkObject
+from ResSimpy.Units.AttributeMappings.BaseUnitMapping import BaseUnitMapping
+
+
+@dataclass(kw_only=True, repr=False)
+class NexusStreamTracer(NetworkObject):
+    """Represents a single row in a Nexus STREAM_TRACER table.
+
+    A STREAM_TRACER block associates named streams with a fluid component and
+    an optional tracer name and concentration, e.g.::
+
+        STREAM_TRACER
+        NAME       COMPONENT   TRACER   CONCENTRATION
+        SEAWTR     WATER       SALT     1.0
+        TRTWTR     WATER       SALT     1.0
+        ENDSTREAM_TRACER
+
+    Attributes:
+        name (str): The stream name (NAME column). Used in WELLS tables as the STREAM value.
+        component (str): The fluid component associated with this stream (COMPONENT column),
+            e.g. ``'WATER'``, ``'GAS'``, ``'OIL'``.
+        tracer (Optional[str]): The tracer label (TRACER column). Defaults to None.
+        concentration (Optional[float]): Tracer concentration (CONCENTRATION column). Defaults to None.
+    """
+
+    component: str | None = None
+    tracer: str | None = None
+    concentration: float | None = None
+
+    def __init__(
+        self,
+        properties_dict: DataObjectMixinDictType | None = None,
+        date: str | None = None,
+        date_format: DateFormat | None = None,
+        start_date: str | None = None,
+        unit_system: UnitSystem | None = None,
+        name: str | None = None,
+        component: str | None = None,
+        tracer: str | None = None,
+        concentration: float | None = None,
+    ) -> None:
+        """Initialises the NexusStreamTracer class.
+
+        Args:
+            properties_dict (Optional[dict]): dict of the properties to set on the object.
+            date (Optional[str]): The date of the object.
+            date_format (Optional[DateFormat]): The date format that the object uses.
+            start_date (Optional[str]): The start date of the model.
+            unit_system (Optional[UnitSystem]): The unit system of the object e.g. ENGLISH, METRIC.
+            name (Optional[str]): The stream name (NAME column).
+            component (Optional[str]): Fluid component, e.g. ``'WATER'``, ``'GAS'``, ``'OIL'``.
+            tracer (Optional[str]): Tracer label (TRACER column).
+            concentration (Optional[float]): Tracer concentration (CONCENTRATION column).
+        """
+        self.component = component
+        self.tracer = tracer
+        self.concentration = concentration
+
+        super().__init__(
+            properties_dict=properties_dict,
+            date=date,
+            date_format=date_format,
+            start_date=start_date,
+            unit_system=unit_system,
+            name=name,
+        )
+
+    @staticmethod
+    def get_keyword_mapping() -> dict[str, tuple[str, type]]:
+        """Gets the mapping of Nexus STREAM_TRACER column headers to attribute definitions."""
+        return {
+            'NAME': ('name', str),
+            'COMPONENT': ('component', str),
+            'TRACER': ('tracer', str),
+            'CONCENTRATION': ('concentration', float),
+        }
+
+    @property
+    def units(self) -> BaseUnitMapping:
+        """Returns the attribute-to-unit map for this data object."""
+        return BaseUnitMapping(unit_system=self.unit_system)

ressimpy-2.6.0/ResSimpy/Nexus/DataModels/Network/NexusStreamTracers.py

@@ -0,0 +1,73 @@
+"""Container class for Nexus STREAM_TRACER entries."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Sequence, TYPE_CHECKING
+
+from ResSimpy.Nexus.DataModels.Network.NexusStreamTracer import NexusStreamTracer
+
+if TYPE_CHECKING:
+    from ResSimpy.Nexus.NexusNetwork import NexusNetwork
+
+
+@dataclass(kw_only=True)
+class NexusStreamTracers:
+    """Container for all :class:`NexusStreamTracer` objects parsed from STREAM_TRACER blocks.
+
+    Also exposes a :py:attr:`component_map` property that returns a ``dict[str, str]``
+    mapping each stream name (uppercased) to its declared COMPONENT, which is used by
+    :class:`~ResSimpy.Nexus.NexusNetwork.NexusNetwork` to classify well types.
+    """
+
+    __stream_tracers: list[NexusStreamTracer] = field(default_factory=list)
+
+    def __init__(self, parent_network: NexusNetwork) -> None:
+        """Initialises the NexusStreamTracers class.
+
+        Args:
+            parent_network (NexusNetwork): The network that these stream tracers belong to.
+        """
+        self.__parent_network: NexusNetwork = parent_network
+        self.__stream_tracers: list[NexusStreamTracer] = []
+
+    def get_all(self) -> Sequence[NexusStreamTracer]:
+        """Returns all loaded :class:`NexusStreamTracer` objects."""
+        self.__parent_network.get_load_status()
+        return self.__stream_tracers
+
+    def get_by_name(self, name: str) -> NexusStreamTracer | None:
+        """Returns the first :class:`NexusStreamTracer` whose stream name matches *name* (case-insensitive).
+
+        Args:
+            name (str): Stream name to look up.
+
+        Returns:
+            NexusStreamTracer | None: Matching object, or ``None`` if not found.
+        """
+        self.__parent_network.get_load_status()
+        name_upper = name.upper()
+        for st in self.__stream_tracers:
+            if st.name is not None and st.name.upper() == name_upper:
+                return st
+        return None
+
+    @property
+    def component_map(self) -> dict[str, str]:
+        """Returns a ``dict`` mapping stream name → component (both uppercased).
+
+        Example::
+
+            {'SEAWTR': 'WATER', 'TRTWTR': 'WATER', 'GASSTREAM': 'GAS'}
+        """
+        self.__parent_network.get_load_status()
+        return {
+            st.name.upper(): st.component.upper()
+            for st in self.__stream_tracers
+            if st.name is not None and st.component is not None
+        }
+
+    def _add_to_memory(self, stream_tracers_to_add: list[NexusStreamTracer] | None) -> None:
+        """Appends a list of :class:`NexusStreamTracer` objects to the internal store."""
+        if stream_tracers_to_add is None:
+            return
+        self.__stream_tracers.extend(stream_tracers_to_add)

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/Nexus/DataModels/Network/NexusWellLists.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Literal, Sequence
 
 from ResSimpy.DataModelBaseClasses.NetworkList import NetworkList
 from ResSimpy.GenericContainerClasses.NetworkLists import NetworkLists
-from ResSimpy.Nexus.DataModels.NexusWellList import NexusWellList
+from ResSimpy.Nexus.DataModels.Network.NexusWellList import NexusWellList
 
 if TYPE_CHECKING:
     from ResSimpy.Nexus.NexusNetwork import NexusNetwork

{ressimpy-2.5.2 → ressimpy-2.6.0}/ResSimpy/Nexus/DataModels/NexusFile.py

@@ -152,7 +152,7 @@ class NexusFile(File):
                         include_file = obj
                         break
                     if obj.location is not None and \
-                            os.path.basename(obj.location) == os.path.basename(incfile_location):
+                            obj.location_in_including_file == incfile_location:
                         include_file = obj
                         break