ResSimpy 2.5.1__tar.gz → 2.5.3__tar.gz

{ressimpy-2.5.1 → ressimpy-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ResSimpy
-Version: 2.5.1
+Version: 2.5.3
 Summary: A Python library for working with Reservoir Simulator Models.
 License: Apache-2.0
 License-File: LICENSE.MD

{ressimpy-2.5.1 → ressimpy-2.5.3}/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:
@@ -785,3 +787,39 @@ def split_line(line: str, upper: bool = True, comment_characters: None | list[st
         value = get_next_value(0, [trimmed_line], comment_characters=comment_characters)
 
     return stored_values
+
+
+def split_file_as_list_by_date(file_as_list: list[str], date_token: str = 'TIME',
+                               comment_characters: None | list[str] = None) -> dict[str, list[str]]:
+    """Splits a file represented as a list of strings into a dictionary of lists of strings based on the token
+    specified.
+
+    Args:
+        file_as_list (list[str]): a list of strings containing each line of the file as a new entry
+        date_token (str): The date token to split on. Defaults to Nexus format.
+        comment_characters (Optional[list[str]], optional): a list of characters that are considered inline comments.
+            Defaults to the Nexus format (!)
+
+    Returns:
+        dict[str, list[str]]: a dictionary where the keys are the token followed by the first value after the token,
+        and the values are lists of strings containing the lines of the file between that token and the next occurrence
+        of that token.
+    """
+    split_file: dict[str, list[str]] = {}
+    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
+            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.1 → ressimpy-2.5.3}/ResSimpy/GenericContainerClasses/NetworkLists.py

@@ -76,6 +76,6 @@ class NetworkLists(ABC):
             printable_string += f'{self.table_header()} {list_item.name}\n'
             # remove all the previous wells and reinitialise the list
             printable_string += 'CLEAR\nADD\n'
-            printable_string += ' '.join(list_item.elements_in_the_list) + '\n'
+            printable_string += '\n'.join(list_item.elements_in_the_list) + '\n'
             printable_string += self.table_footer() + '\n'
         return printable_string

{ressimpy-2.5.1 → ressimpy-2.5.3}/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.1 → ressimpy-2.5.3}/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.5.3/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.5.3/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.1 → ressimpy-2.5.3}/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.1 → ressimpy-2.5.3}/ResSimpy/Nexus/DataModels/Network/NexusWellhead.py

@@ -61,7 +61,7 @@ class NexusWellhead(Wellhead):
     heat_transfer_coeff: Optional[float] = None
     dt_add: Optional[float] = None
 
-    def __init__(self, properties_dict: DataObjectMixinDictType, date: Optional[str] = None,
+    def __init__(self, properties_dict: Optional[DataObjectMixinDictType] = None, date: Optional[str] = None,
                  date_format: Optional[DateFormat] = None, start_date: Optional[str] = None,
                  unit_system: Optional[UnitSystem] = None, name: Optional[str] = None, pvt_method: Optional[int] = None,
                  water_method: Optional[int] = None, bat_method: Optional[int] = None,
@@ -77,7 +77,8 @@ class NexusWellhead(Wellhead):
         """Initialises the NexusWellhead class.
 
         Args:
-            properties_dict (dict): dict of the properties to set on the object.
+            properties_dict (Optional[dict]): optional way of importing via a 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. Required if the object uses a decimal TIME.

{ressimpy-2.5.1 → ressimpy-2.5.3}/ResSimpy/Nexus/DataModels/StructuredGrid/NexusGrid.py

@@ -6,7 +6,7 @@ import copy
 import numpy as np
 import pandas as pd
 from dataclasses import dataclass, field
-from typing import Optional, TYPE_CHECKING, Any, Final
+from typing import TYPE_CHECKING, Any, Final
 import warnings
 from sys import maxsize
 
@@ -43,14 +43,14 @@ class PropertyToLoad:
 
 @dataclass(kw_only=True)
 class NexusGrid(Grid):
-    __array_functions_list: Optional[list[list[str]]] = None
-    __array_functions_df: Optional[pd.DataFrame] = None
+    __array_functions_list: list[list[str]] | None = None
+    __array_functions_df: pd.DataFrame | None = None
     __array_functions_loaded: bool = False
-    __grid_file_contents: Optional[list[str]] = None
-    __grid_file_nested: Optional[list[str]] = None
-    __faults_df: Optional[pd.DataFrame] = None
+    __grid_file_contents: list[str] | None = None
+    __grid_file_nested: list[str] | None = None
+    __faults_df: pd.DataFrame | None = None
     __grid_faults_loaded: bool = False
-    __grid_nexus_file: Optional[NexusFile] = None
+    __grid_nexus_file: NexusFile | None = None
     __corp: GridArrayDefinition
     __dx: GridArrayDefinition
     __dy: GridArrayDefinition
@@ -125,14 +125,14 @@ class NexusGrid(Grid):
     __kyeff: GridArrayDefinition
     __kzeff: GridArrayDefinition
     __grid_multir_loaded: bool = False
-    __multir: Optional[list[NexusMultir]] = None
+    __multir: list[NexusMultir] | None = None
     __lgrs: NexusLGRs
     __overs: list[NexusOver] = field(default_factory=list)
     __tovers: list[NexusTOver] = field(default_factory=list)
     __ftrans: list[NexusFtrans] = field(default_factory=list)
     __model_unit_system: UnitSystem
 
-    def __init__(self, model_unit_system: UnitSystem, grid_nexus_file: Optional[NexusFile] = None,
+    def __init__(self, model_unit_system: UnitSystem, grid_nexus_file: NexusFile | None = None,
                  assume_loaded: bool = False,
                  ) -> None:
         """Initialises the NexusGrid class.
@@ -146,15 +146,15 @@ class NexusGrid(Grid):
         super().__init__(assume_loaded=assume_loaded)
         self.__array_functions_loaded: bool = assume_loaded
         self.__grid_faults_loaded: bool = assume_loaded
-        self.__array_functions_list: Optional[list[list[str]]] = None
-        self.__array_functions_df: Optional[pd.DataFrame] = None
-        self.__grid_file_contents: Optional[list[str]] = None if grid_nexus_file is None else \
+        self.__array_functions_list: list[list[str]] | None = None
+        self.__array_functions_df: pd.DataFrame | None = None
+        self.__grid_file_contents: list[str] | None = None if grid_nexus_file is None else \
             grid_nexus_file.get_flat_list_str_file_including_includes
-        self.__grid_file_nested: Optional[list[str]] = None if grid_nexus_file is None else \
+        self.__grid_file_nested: list[str] | None = None if grid_nexus_file is None else \
             grid_nexus_file.file_content_as_list
-        self.__faults_df: Optional[pd.DataFrame] = None
-        self.__grid_nexus_file: Optional[NexusFile] = grid_nexus_file
-        self.__grid_array_functions: Optional[list[NexusGridArrayFunction]] = None
+        self.__faults_df: pd.DataFrame | None = None
+        self.__grid_nexus_file: NexusFile | None = grid_nexus_file
+        self.__grid_array_functions: list[NexusGridArrayFunction] | None = None
         self.__corp: GridArrayDefinition = GridArrayDefinition()
         self.__iequil: GridArrayDefinition = GridArrayDefinition()
         self.__ipvt: GridArrayDefinition = GridArrayDefinition()
@@ -257,14 +257,14 @@ class NexusGrid(Grid):
         # Prevent reload from disk
         self._grid_properties_loaded = True
 
-    def to_dict(self) -> dict[str, Optional[int] | GridArrayDefinition]:
+    def to_dict(self) -> dict[str, int | None | GridArrayDefinition]:
         """Returns a dictionary representation of grid array.
         Checks if grid properties are not loaded and loads them.
         """
         self.load_grid_properties_if_not_loaded()
 
         original_dict = self.__dict__
-        new_dict: dict[str, Optional[int] | GridArrayDefinition] = {}
+        new_dict: dict[str, int | None | GridArrayDefinition] = {}
         for key in original_dict.keys():
             new_key = key
             if new_key[0] == '_':
@@ -709,13 +709,13 @@ class NexusGrid(Grid):
         self.__array_functions_df = afo.summarize_model_functions(self.__array_functions_list)
         self.__array_functions_loaded = True
 
-    def get_array_functions_list(self) -> Optional[list[list[str]]]:
+    def get_array_functions_list(self) -> list[list[str]] | None:
         """Returns the grid array functions as a list of function lines."""
         if not self.__array_functions_loaded:
             self.load_array_functions()
         return self.__array_functions_list
 
-    def get_array_functions_df(self) -> Optional[pd.DataFrame]:
+    def get_array_functions_df(self) -> pd.DataFrame | None:
         """Returns the grid array functions as a dataframe."""
         if not self.__array_functions_loaded:
             self.load_array_functions()
@@ -753,7 +753,7 @@ class NexusGrid(Grid):
             self.__faults_df = new_df.drop(['TMULT'], axis=1)
         self.__grid_faults_loaded = True
 
-    def get_faults_df(self) -> Optional[pd.DataFrame]:
+    def get_faults_df(self) -> pd.DataFrame | None:
         """Returns the fault definition and transmissility multiplier information as a dataframe."""
         self.load_grid_properties_if_not_loaded()
         if not self.__grid_faults_loaded:
@@ -804,7 +804,7 @@ class NexusGrid(Grid):
     def __extract_multir_tableline(line: str) -> None | NexusMultir:
         """Takes a single line in a file and extracts a Multir object from it."""
         stored_values = fo.split_line(line)
-        if not stored_values:
+        if not stored_values or len(stored_values) < 3:
             return None
         region_1_str, region_2_str, tmult_str = stored_values[0:3]
         region_1 = int(region_1_str)
@@ -854,7 +854,7 @@ class NexusGrid(Grid):
             return None
 
     @property
-    def array_functions(self) -> Optional[list[NexusGridArrayFunction]]:
+    def array_functions(self) -> list[NexusGridArrayFunction] | None:
         """Returns a list of the array functions defined in the structured grid file."""
         self.load_grid_properties_if_not_loaded()
         if self.__grid_array_functions is None:
@@ -1814,7 +1814,8 @@ class NexusGrid(Grid):
 
         # add the faults
         faults_df = self.get_faults_df()
-        grid_str += NexusGrid.fault_df_to_string(faults_df)
+        if faults_df is not None and not faults_df.empty:
+            grid_str += NexusGrid.fault_df_to_string(faults_df)
 
         if self.array_functions:
             for array_function in self.array_functions: