res2df 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

res2df/gruptree.py

@@ -7,7 +7,7 @@ import datetime
 import logging
 import sys
 import warnings
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -15,8 +15,6 @@ import treelib
 
 with contextlib.suppress(ImportError):
     # Needed for mypy
-
-    # pylint: disable=unused-import
     import opm.io
 
 from .common import (
@@ -33,8 +31,8 @@ logger = logging.getLogger(__name__)
 
 
 def df(
-    deck: Union[ResdataFiles, "opm.libopmcommon_python.Deck"],
-    startdate: Optional[datetime.date] = None,
+    deck: "ResdataFiles | opm.opmcommon_python.Deck",
+    startdate: datetime.date | None = None,
     welspecs: bool = True,
 ) -> pd.DataFrame:
     """Extract all group information from a :term:`deck`
@@ -64,7 +62,7 @@ def df(
         information is found in :term:`deck`.
     """
 
-    date: Optional[datetime.date]
+    date: datetime.date | None
     date = startdate if startdate is not None else None
 
     if isinstance(deck, ResdataFiles):
@@ -76,16 +74,16 @@ def df(
     # In order for the GRUPTREE/BRANPROP keywords to accumulate, we
     # store the edges as dictionaries indexed by the edge
     # (which is a tuple of child and parent).
-    currentedges: Dict[str, Dict[Tuple[str, str], Dict[str, Any]]] = {
+    currentedges: dict[str, dict[tuple[str, str], dict[str, Any]]] = {
         "GRUPTREE": {},
         "BRANPROP": {},
     }
     # Same approach for the welspecs keywords
-    wellspecsedges: Dict[Tuple[str, str], str] = {}
+    wellspecsedges: dict[tuple[str, str], str] = {}
     # Node properties from GRUPNET/NODEPROP is stored in a dataframe
     # Note that it's not allowed to mix GRUPNET and NODEPROP in eclipse
     # so the datframe will only contain columns from one of them
-    nodedata: Dict[str, pd.DataFrame] = {
+    nodedata: dict[str, pd.DataFrame] = {
         "GRUPNET": pd.DataFrame(),
         "NODEPROP": pd.DataFrame(),
     }
@@ -115,7 +113,7 @@ def df(
             if kword.name in ["DATES", "START"]:
                 for rec in kword:
                     date = parse_opmio_date_rec(rec)
-                    logger.debug("Parsing at date %s", str(date))
+                    logger.debug("Parsing at date %s", date)
             elif kword.name == "TSTEP":
                 assert date is not None
                 for rec in kword:
@@ -123,9 +121,7 @@ def df(
                     # Assuming not LAB units, then the unit is days.
                     days = sum(steplist)
                     date += datetime.timedelta(days=days)
-                    logger.info(
-                        "Advancing %s days to %s through TSTEP", str(days), str(date)
-                    )
+                    logger.info("Advancing %s days to %s through TSTEP", days, date)
         if kword.name in ["GRUPTREE", "BRANPROP"]:
             found_keywords[kword.name] = True
             renamer = (
@@ -137,13 +133,13 @@ def df(
                 edge_dict = parse_opmio_deckrecord(edgerec, kword.name, renamer=renamer)
                 child = edge_dict.pop("CHILD_GROUP")
                 parent = edge_dict.pop("PARENT_GROUP")
-                currentedges[kword.name][(child, parent)] = edge_dict
+                currentedges[kword.name][child, parent] = edge_dict
 
         if kword.name == "WELSPECS" and welspecs:
             found_keywords["WELSPECS"] = True
             for wellrec in kword:
                 wspc_dict = parse_opmio_deckrecord(wellrec, "WELSPECS")
-                wellspecsedges[(wspc_dict["WELL"], wspc_dict["GROUP"])] = "WELSPECS"
+                wellspecsedges[wspc_dict["WELL"], wspc_dict["GROUP"]] = "WELSPECS"
 
         if kword.name in ["GRUPNET", "NODEPROP"]:
             found_keywords[kword.name] = True
@@ -189,12 +185,12 @@ def df(
 
 
 def _write_edgerecords(
-    currentedges: Dict[str, Dict[Tuple[str, str], Dict[str, Any]]],
-    nodedata: Dict[str, pd.DataFrame],
-    wellspecsedges: Dict[Tuple[str, str], str],
+    currentedges: dict[str, dict[tuple[str, str], dict[str, Any]]],
+    nodedata: dict[str, pd.DataFrame],
+    wellspecsedges: dict[tuple[str, str], str],
     found_keywords: dict,
-    date: Optional[datetime.date],
-) -> List[dict]:
+    date: datetime.date | None,
+) -> list[dict]:
     """Writes a new GRUPTREE tree if there are new instances of
     GRUPTREE, GRUPNET or WELSPECS and writes a new BRANPROP tree
     if there are new instances of BRANPROP, NODEPROP or WELSPECS.
@@ -219,12 +215,12 @@ def _write_edgerecords(
 
 
 def _merge_edges_and_nodeinfo(
-    currentedges: Dict[Tuple[str, str], Dict[str, Any]],
+    currentedges: dict[tuple[str, str], dict[str, Any]],
     nodedata_df: pd.DataFrame,
-    wellspecsedges: Dict[Tuple[str, str], str],
-    date: Optional[datetime.date],
+    wellspecsedges: dict[tuple[str, str], str],
+    date: datetime.date | None,
     treetype: str,
-) -> List[dict]:
+) -> list[dict[str, Any]]:
     """Merge a list of edges with information from the nodedata dataframe.
 
     Edges where there is no parent (root nodes) are identified and added
@@ -241,7 +237,7 @@ def _merge_edges_and_nodeinfo(
     Returns:
         List of dictionaries (that can be made into a dataframe)
     """
-    edgerecords = []
+    edgerecords: list[dict[str, Any]] = []
     childs = set()
     parents = set()
     # Write GRUPTREE/BRANPROP edges
@@ -253,7 +249,9 @@ def _merge_edges_and_nodeinfo(
         rec_dict.update(edge_dict)
         # Add node data
         if child in nodedata_df.index:
-            rec_dict.update(nodedata_df.loc[child])
+            rec_dict.update(
+                {str(k): v for k, v in nodedata_df.loc[child].to_dict().items()}
+            )
         edgerecords.append(rec_dict)
 
     # Write WELSPECS edges
@@ -280,16 +278,18 @@ def _merge_edges_and_nodeinfo(
         parents |= {"FIELD"}
 
     roots = parents - childs
-    rootrecords = []
+    rootrecords: list[dict[str, Any]] = []
     for root in roots:
         rec_dict = {"DATE": date, "CHILD": root, "KEYWORD": treetype}
         if root in nodedata_df.index:
-            rec_dict.update(nodedata_df.loc[root])
+            rec_dict.update(
+                {str(k): v for k, v in nodedata_df.loc[root].to_dict().items()}
+            )
         rootrecords.append(rec_dict)
     return rootrecords + edgerecords
 
 
-def edge_dataframe2dict(dframe: pd.DataFrame) -> List[dict]:
+def edge_dataframe2dict(dframe: pd.DataFrame) -> list[dict]:
     """Convert list of edges in a dataframe into a
     nested dictionary (tree).
 
@@ -321,7 +321,7 @@ def edge_dataframe2dict(dframe: pd.DataFrame) -> List[dict]:
     subtrees: dict = collections.defaultdict(dict)
     edges = []  # List of tuples
     for _, row in dframe.iterrows():
-        if not pd.isnull(row["PARENT"]):
+        if not pd.isna(row["PARENT"]):
             edges.append((row["CHILD"], row["PARENT"]))
     for child, parent in edges:
         subtrees[parent][child] = subtrees[child]
@@ -332,7 +332,7 @@ def edge_dataframe2dict(dframe: pd.DataFrame) -> List[dict]:
 
 
 def _add_to_tree_from_dict(
-    nested_dict: dict, name: str, tree: treelib.Tree, parent: Optional[str] = None
+    nested_dict: dict, name: str, tree: treelib.Tree, parent: str | None = None
 ) -> None:
     assert isinstance(nested_dict, dict)
     tree.create_node(name, name, parent=parent)
@@ -361,7 +361,7 @@ def tree_from_dict(nested_dict: dict) -> treelib.Tree | str:
             "The dict given to tree_from_dict() must have "
             "exactly one top level key, representing a single tree."
         )
-    root_name = list(nested_dict.keys())[0]
+    root_name = next(iter(nested_dict.keys()))
     tree = treelib.Tree()
     _add_to_tree_from_dict(nested_dict[root_name], root_name, tree)
     return tree
@@ -459,9 +459,7 @@ def prettyprint(dframe: pd.DataFrame) -> str:
 
 def gruptree_main(args) -> None:
     """Entry-point for module, for command line utility."""
-    logger = getLogger_res2csv(  # pylint: disable=redefined-outer-name
-        __name__, vars(args)
-    )
+    logger = getLogger_res2csv(__name__, vars(args))
     if not args.output and not args.prettyprint:
         print("Nothing to do. Set --output or --prettyprint")
         sys.exit(0)

res2df/inferdims.py

@@ -5,7 +5,6 @@ reservoir simulator decks (typically single include-files)
 
 import contextlib
 import logging
-from typing import Dict, Optional, Union
 
 with contextlib.suppress(ImportError):
     import opm.io
@@ -16,7 +15,7 @@ from .resdatafiles import ResdataFiles
 logger = logging.getLogger(__name__)
 
 # Constants to use for pointing to positions in the xxxDIMS keyword
-DIMS_POS: Dict[str, int] = {"NTPVT": 1, "NTSFUN": 0, "NTEQUL": 0}
+DIMS_POS: dict[str, int] = {"NTPVT": 1, "NTSFUN": 0, "NTEQUL": 0}
 
 
 def guess_dim(deckstring: str, dimkeyword: str, dimitem: int = 0) -> int:
@@ -138,9 +137,9 @@ def inject_dimcount(
 def inject_xxxdims_ntxxx(
     xxxdims: str,
     ntxxx_name: str,
-    deck: Union[str, "opm.libopmcommon_python.Deck"],
-    ntxxx_value: Optional[int] = None,
-) -> "opm.libopmcommon_python.Deck":
+    deck: "str | opm.opmcommon_python.Deck",
+    ntxxx_value: int | None = None,
+) -> "opm.opmcommon_python.Deck":
     """Ensures TABDIMS/EQLDIMS is present in a :term:`deck`.
 
     If ntxxx_value=None and ntxxx_name not in the :term:`deck`, ntxxx_name will
@@ -169,9 +168,7 @@ def inject_xxxdims_ntxxx(
         return deck
 
     if xxxdims in deck and ntxxx_value is not None:
-        logger.warning(
-            "Ignoring %s argument, it is already in the deck", str(ntxxx_name)
-        )
+        logger.warning("Ignoring %s argument, it is already in the deck", ntxxx_name)
         return deck
 
     if not isinstance(deck, str):
@@ -182,7 +179,7 @@ def inject_xxxdims_ntxxx(
     # Estimate if ntxxx_value is not provided:
     if ntxxx_value is None:
         ntxxx_estimate = guess_dim(deck, xxxdims, DIMS_POS[ntxxx_name])
-        logger.warning("Estimated %s=%s", ntxxx_name, str(ntxxx_estimate))
+        logger.warning("Estimated %s=%s", ntxxx_name, ntxxx_estimate)
     else:
         ntxxx_estimate = ntxxx_value
 

res2df/nnc.py

@@ -8,7 +8,6 @@ import datetime
 import logging
 import os
 from pathlib import Path
-from typing import Optional
 
 import pandas as pd
 
@@ -124,15 +123,13 @@ def add_nnc_coords(nncdf: pd.DataFrame, resdatafiles: ResdataFiles) -> pd.DataFr
         Incoming dataframe augmented with the columns X, Y and Z.
     """
     gridgeometry = gridgeometry2df(resdatafiles)
-    gnncdf = pd.merge(
-        nncdf,
+    gnncdf = nncdf.merge(
         gridgeometry,
         how="left",
         left_on=["I1", "J1", "K1"],
         right_on=["I", "J", "K"],
     )
-    gnncdf = pd.merge(
-        gnncdf,
+    gnncdf = gnncdf.merge(
         gridgeometry,
         how="left",
         left_on=["I2", "J2", "K2"],
@@ -147,7 +144,7 @@ def add_nnc_coords(nncdf: pd.DataFrame, resdatafiles: ResdataFiles) -> pd.DataFr
     gnncdf["Z"] = gnncdf[["Z", "Z_2"]].mean(axis=1)
 
     # Let go of the temporary columns we have in gnncdf
-    return gnncdf[list(nncdf.columns) + ["X", "Y", "Z"]]
+    return gnncdf[[*list(nncdf.columns), "X", "Y", "Z"]]
 
 
 def filter_vertical(nncdf: pd.DataFrame) -> pd.DataFrame:
@@ -207,7 +204,7 @@ def fill_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
 
 
 def df2res_editnnc(
-    nnc_df: pd.DataFrame, filename: Optional[str] = None, nocomments: bool = False
+    nnc_df: pd.DataFrame, filename: str | None = None, nocomments: bool = False
 ) -> str:
     """Write an EDITNNC keyword
 
@@ -285,9 +282,7 @@ def df2res_editnnc(
 
 def nnc_main(args) -> None:
     """Command line access point from main() or from res2csv via subparser"""
-    logger = getLogger_res2csv(  # pylint: disable=redefined-outer-name
-        __name__, vars(args)
-    )
+    logger = getLogger_res2csv(__name__, vars(args))
     resdatafiles = ResdataFiles(args.DATAFILE)
     nncdf = df(resdatafiles, coords=args.coords, pillars=args.pillars)
     write_dframe_stdout_file(

res2df/parameters.py

@@ -5,7 +5,7 @@ import json
 import logging
 import warnings
 from pathlib import Path
-from typing import Any, Dict, List, Union
+from typing import Any
 
 import pandas as pd
 import yaml
@@ -16,8 +16,8 @@ logger = logging.getLogger(__name__)
 
 
 def find_parameter_files(
-    deckpath: Union[ResdataFiles, str, Path], filebase: str = "parameters"
-) -> List[Path]:
+    deckpath: ResdataFiles | str | Path, filebase: str = "parameters"
+) -> list[Path]:
     """Locate a default prioritized list of files to try to read as key-value
 
     File extensions .yml, .json and .txt are recognized and will be found in
@@ -41,13 +41,13 @@ def find_parameter_files(
         eclbasepath = Path(deckpath).parent.absolute()
     else:
         raise TypeError
-    files_to_lookfor: List[str] = [
+    files_to_lookfor: list[str] = [
         filebase + ".json",
         filebase + ".yml",
         filebase + ".txt",
         filebase,
     ]
-    paths_to_check: List[Path] = [Path("."), Path(".."), Path("..") / Path("..")]
+    paths_to_check: list[Path] = [Path("."), Path(".."), Path("..") / Path("..")]
     foundfiles = []
     for path in paths_to_check:
         for fname in files_to_lookfor:
@@ -57,7 +57,7 @@ def find_parameter_files(
     return foundfiles
 
 
-def load_parameterstxt(filename: Union[str, Path]) -> Dict[str, Any]:
+def load_parameterstxt(filename: str | Path) -> dict[str, Any]:
     """Read parameters.txt into a dictionary
 
     Lines starting with a hash will be ignored.
@@ -87,8 +87,8 @@ def load_parameterstxt(filename: Union[str, Path]) -> Dict[str, Any]:
 
 
 def load_all(
-    filenames: Union[List[str], List[Path]], warnduplicates: bool = True
-) -> Dict[str, Any]:
+    filenames: list[str] | list[Path], warnduplicates: bool = True
+) -> dict[str, Any]:
     """Reads a list of parameter filenames
 
     Dictionaries for all files will be merged into one.
@@ -101,19 +101,19 @@ def load_all(
         filenames: Order matters.
         warnduplicates: If True (default), overlapping keys will be warned.
     """
-    keyvalues: Dict[str, Any] = {}
+    keyvalues: dict[str, Any] = {}
     for fname in filenames:
         new_params = load(fname)
         if warnduplicates and keyvalues:
             duplicates = set(keyvalues.keys()).intersection(set(new_params.keys()))
             if duplicates:
-                logger.debug("Duplicates keys %s", str(duplicates))
+                logger.debug("Duplicates keys %s", duplicates)
         new_params.update(keyvalues)
         keyvalues = new_params
     return keyvalues
 
 
-def load(filename: Union[str, Path]) -> Dict[str, Any]:
+def load(filename: str | Path) -> dict[str, Any]:
     """Read a parameter file as txt, yaml or json
 
     Returns:
@@ -168,7 +168,7 @@ def load(filename: Union[str, Path]) -> Dict[str, Any]:
 
     if not params_dict:
         logger.warning("%s could not be parsed as yaml, json or txt", filename)
-        logger.warning("%s%s%s", str(yaml_error), str(json_error), str(txt_error))
+        logger.warning("%s%s%s", yaml_error, json_error, txt_error)
         raise ValueError(f"Could not parse {filename}")
 
     # Filter to values that are NOT dict's. We can have dict as value when

res2df/pillars.py

@@ -3,7 +3,6 @@
 import argparse
 import datetime
 import logging
-from typing import Dict, List, Optional, Union
 
 import dateutil.parser
 import pandas as pd
@@ -16,7 +15,7 @@ from .resdatafiles import ResdataFiles
 
 logger: logging.Logger = logging.getLogger(__name__)
 
-AGGREGATORS: Dict[str, str] = {
+AGGREGATORS: dict[str, str] = {
     "VOLUME": "sum",
     "PORV": "sum",
     "PERMX": "mean",
@@ -38,8 +37,8 @@ AGGREGATORS: Dict[str, str] = {
 
 def df(
     resdatafiles: ResdataFiles,
-    region: Optional[str] = None,
-    rstdates: Optional[Union[str, datetime.date, List[datetime.date]]] = None,
+    region: str | None = None,
+    rstdates: str | datetime.date | list[datetime.date] | None = None,
     soilcutoff: float = 0.2,
     sgascutoff: float = 0.7,
     swatcutoff: float = 0.7,
@@ -135,16 +134,14 @@ def df(
                 datestr=datestr,
             )
             if not contacts.empty:
-                grouped = pd.merge(grouped, contacts, how="left")
+                grouped = grouped.merge(contacts, how="left")
 
     if stackdates:
         return stack_on_colnames(grouped, sep="@", stackcolname="DATE", inplace=True)
     return grouped
 
 
-def compute_volumes(
-    grid_df: pd.DataFrame, datestr: Optional[str] = None
-) -> pd.DataFrame:
+def compute_volumes(grid_df: pd.DataFrame, datestr: str | None = None) -> pd.DataFrame:
     """Compute "dynamic" volumes, volumes for data coming from the
     UNRST file (SWAT+SGAS)
 
@@ -194,11 +191,11 @@ def compute_volumes(
 
 def compute_pillar_contacts(
     grid_df: pd.DataFrame,
-    region: Optional[str] = None,
+    region: str | None = None,
     soilcutoff: float = 0.2,
     sgascutoff: float = 0.7,
     swatcutoff: float = 0.7,
-    datestr: Optional[str] = None,
+    datestr: str | None = None,
 ) -> pd.DataFrame:
     """Compute contacts pr. pillar in a grid dataframe.
 
@@ -268,21 +265,21 @@ def compute_pillar_contacts(
         .reset_index()
     )
     if soilcutoff and "SOIL" + atdatestr in grid_df:
-        logger.info(
-            "Calculating oil-water-contacts based on SOILcutoff %s", str(soilcutoff)
-        )
+        logger.info("Calculating oil-water-contacts based on SOILcutoff %s", soilcutoff)
         owc = (
-            grid_df[grid_df["SOIL" + atdatestr] > soilcutoff]
-            .groupby(groupbies)
-            .agg({"Z": "max"})
+            (
+                grid_df[grid_df["SOIL" + atdatestr] > soilcutoff]
+                .groupby(groupbies)
+                .agg({"Z": "max"})
+            )
+            .rename(columns={"Z": "OWC" + atdatestr})
+            .reset_index()
         )
-        owc.rename(columns={"Z": "OWC" + atdatestr}, inplace=True)
-        owc.reset_index(inplace=True)
         # Filter the owc frame to only those pillars that also has water:
-        owc = pd.merge(waterpillars, owc, how="inner").drop("Z", axis="columns")
+        owc = waterpillars.merge(owc, how="inner").drop("Z", axis="columns")
 
     if sgascutoff and "SGAS" + atdatestr in grid_df:
-        logger.info("Calculating gas-contacts based on gas cutoff %s", str(sgascutoff))
+        logger.info("Calculating gas-contacts based on gas cutoff %s", sgascutoff)
         if "SOIL" + atdatestr in grid_df and "SGAS" + atdatestr in grid_df:
             # Pillars to be used for GOC computation
             gocpillars = (
@@ -298,8 +295,7 @@ def compute_pillar_contacts(
                 ]
                 .groupby(groupbies)
                 .agg({"Z": "max"})
-            )
-            goc.rename(columns={"Z": "GOC" + atdatestr}, inplace=True)
+            ).rename(columns={"Z": "GOC" + atdatestr})
         else:
             # Two-phase gas-water: GWC computation
             gocpillars = waterpillars  # In case of gas-water
@@ -307,11 +303,10 @@ def compute_pillar_contacts(
                 grid_df[grid_df["SGAS" + atdatestr] > sgascutoff]
                 .groupby(groupbies)
                 .agg({"Z": "max"})
-            )
-            goc.rename(columns={"Z": "GWC" + atdatestr}, inplace=True)
-        goc.reset_index(inplace=True)
+            ).rename(columns={"Z": "GWC" + atdatestr})
+        goc = goc.reset_index()
         # Filter the goc frame to only those with oil or water:
-        goc = pd.merge(gocpillars, goc, how="inner").drop("Z", axis="columns")
+        goc = gocpillars.merge(goc, how="inner").drop("Z", axis="columns")
 
     # We need to avoid merging with potentially empty DataFrames
     if owc.empty and goc.empty:
@@ -320,7 +315,7 @@ def compute_pillar_contacts(
         return owc
     if owc.empty and not goc.empty:
         return goc
-    return pd.merge(owc, goc)
+    return owc.merge(goc)
 
 
 def fill_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
@@ -413,9 +408,7 @@ def fill_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
 
 def pillars_main(args) -> None:
     """This is the command line API"""
-    logger = getLogger_res2csv(  # pylint: disable=redefined-outer-name
-        __name__, vars(args)
-    )
+    logger = getLogger_res2csv(__name__, vars(args))
 
     resdatafiles = ResdataFiles(args.DATAFILE)
     dframe = df(
@@ -430,7 +423,7 @@ def pillars_main(args) -> None:
     groupbies = []
     aggregators = {
         key: AGGREGATORS[key.split("@")[0]]
-        for key in dframe
+        for key in dframe.columns
         if key.split("@")[0] in AGGREGATORS
     }
     if args.region and args.group: