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

res2df/satfunc.py

@@ -17,12 +17,10 @@ import argparse
 import contextlib
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Union
 
 import pandas as pd
 
 with contextlib.suppress(ImportError):
-    # pylint: disable=unused-import
     import opm.io
 
 from .common import (
@@ -40,7 +38,7 @@ from .resdatafiles import ResdataFiles
 
 logger: logging.Logger = logging.getLogger(__name__)
 
-SUPPORTED_KEYWORDS: List[str] = [
+SUPPORTED_KEYWORDS: list[str] = [
     "SWOF",
     "SGOF",
     "SWFN",
@@ -54,7 +52,7 @@ SUPPORTED_KEYWORDS: List[str] = [
 # RENAMERS are a dictionary of dictionaries, referring to
 # how we should rename deck record items, from the JSON
 # files in opm.common and into Dataframe column names.
-RENAMERS: Dict[str, Dict[str, Union[List[str], str]]] = {}
+RENAMERS: dict[str, dict[str, list[str] | str]] = {}
 RENAMERS["SGFN"] = {"DATA": ["SG", "KRG", "PCOG"]}
 RENAMERS["SGOF"] = {"DATA": ["SG", "KRG", "KROG", "PCOG"]}
 RENAMERS["SGWFN"] = {"DATA": ["SG", "KRG", "KRW", "PCGW"]}
@@ -66,9 +64,9 @@ RENAMERS["SWOF"] = {"DATA": ["SW", "KRW", "KROW", "PCOW"]}
 
 
 def df(
-    deck: Union[str, "opm.libopmcommon_python.Deck"],
-    keywords: Optional[List[str]] = None,
-    ntsfun: Optional[int] = None,
+    deck: "str | ResdataFiles | opm.opmcommon_python.Deck",
+    keywords: list[str] | None = None,
+    ntsfun: int | None = None,
 ) -> pd.DataFrame:
     """Extract the data in the saturation function keywords as a Pandas
     DataFrames.
@@ -124,7 +122,7 @@ def df(
         # SUPPORTED_KEYWORDS (mainly to get WaterOil before GasOil)
         # We do that by converting to a Categorical series:
         dframe["KEYWORD"] = pd.Categorical(dframe["KEYWORD"], SUPPORTED_KEYWORDS)
-        dframe.sort_values(["SATNUM", "KEYWORD"], inplace=True)
+        dframe = dframe.sort_values(["SATNUM", "KEYWORD"])
         dframe["KEYWORD"] = dframe["KEYWORD"].astype(str)
         logger.info(
             "Extracted keywords %s for %i SATNUMs",
@@ -147,14 +145,14 @@ def interpolate_defaults(dframe: pd.DataFrame) -> pd.DataFrame:
     assert len(sat_cols) == 1, (
         f"Could not determine a single saturation column in {dframe.columns}"
     )
-    sat_col = list(sat_cols)[0]
+    sat_col = next(iter(sat_cols))
 
     if dframe[sat_col].isna().any():
         raise ValueError("nan in saturation column is not allowed")
 
     filled_frames = []
     for _, subframe in dframe.groupby("SATNUM"):
-        subframe.set_index(sat_col, inplace=True)
+        subframe = subframe.set_index(sat_col)
         numeric_columns = subframe.select_dtypes(include=["float", "int"]).columns
         subframe[numeric_columns] = subframe[numeric_columns].interpolate(
             method="index", limit_area="inside"
@@ -201,9 +199,7 @@ def fill_reverse_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentPar
 
 def satfunc_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))
     resdatafiles = ResdataFiles(args.DATAFILE)
     if resdatafiles:
         deck = resdatafiles.get_deck()
@@ -234,9 +230,7 @@ def satfunc_main(args) -> None:
 
 def satfunc_reverse_main(args) -> None:
     """For command line utility for CSV to resdata"""
-    logger = getLogger_res2csv(  # pylint: disable=redefined-outer-name
-        __name__, vars(args)
-    )
+    logger = getLogger_res2csv(__name__, vars(args))
     satfunc_df = pd.read_csv(args.csvfile)
     logger.info("Parsed %s", args.csvfile)
     inc_string = df2res(satfunc_df, keywords=args.keywords)
@@ -245,9 +239,9 @@ def satfunc_reverse_main(args) -> None:
 
 def df2res(
     satfunc_df: pd.DataFrame,
-    keywords: Optional[List[str]] = None,
-    comments: Optional[Dict[str, str]] = None,
-    filename: Optional[str] = None,
+    keywords: list[str] | None = None,
+    comments: dict[str, str] | None = None,
+    filename: str | None = None,
 ) -> str:
     """Generate resdata :term:`include file` content from dataframes with
     saturation functions (SWOF, SGOF, ...)
@@ -279,7 +273,7 @@ def df2res(
     return string
 
 
-def df2res_swof(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_swof(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SWOF. Used by df2res().
 
     Args:
@@ -289,7 +283,7 @@ def df2res_swof(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SWOF", dframe, comment)
 
 
-def df2res_sgof(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_sgof(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SGOF. Used by df2res().
 
     Args:
@@ -299,7 +293,7 @@ def df2res_sgof(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SGOF", dframe, comment)
 
 
-def df2res_sgfn(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_sgfn(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SGFN. Used by df2res().
 
     Args:
@@ -309,7 +303,7 @@ def df2res_sgfn(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SGFN", dframe, comment)
 
 
-def df2res_sgwfn(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_sgwfn(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SGWFN. Used by df2res().
 
     Args:
@@ -319,7 +313,7 @@ def df2res_sgwfn(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SGWFN", dframe, comment)
 
 
-def df2res_swfn(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_swfn(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SWFN. Used by df2res().
 
     Args:
@@ -329,7 +323,7 @@ def df2res_swfn(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SWFN", dframe, comment)
 
 
-def df2res_slgof(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_slgof(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SLGOF. Used by df2res().
 
     Args:
@@ -339,7 +333,7 @@ def df2res_slgof(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SLGOF", dframe, comment)
 
 
-def df2res_sof2(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_sof2(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SOF2. Used by df2res().
 
     Args:
@@ -349,7 +343,7 @@ def df2res_sof2(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
     return _df2res_satfuncs("SOF2", dframe, comment)
 
 
-def df2res_sof3(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
+def df2res_sof3(dframe: pd.DataFrame, comment: str | None = None) -> str:
     """Create string with :term:`include file` contents for SOF3. Used by df2res().
 
     Args:
@@ -360,7 +354,7 @@ def df2res_sof3(dframe: pd.DataFrame, comment: Optional[str] = None) -> str:
 
 
 def _df2res_satfuncs(
-    keyword: str, dframe: pd.DataFrame, comment: Optional[str] = None
+    keyword: str, dframe: pd.DataFrame, comment: str | None = None
 ) -> str:
     if dframe.empty:
         return "-- No data!\n"

res2df/summary.py

@@ -6,14 +6,14 @@ import argparse
 import datetime as dt
 import logging
 import os
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 import dateutil
 import numpy as np
 import pandas as pd
-import pyarrow
-import pyarrow.feather
+import pyarrow as pa
 from resdata.summary import Summary
 
 from .common import write_dframe_stdout_file
@@ -27,7 +27,7 @@ logger: logging.Logger = logging.getLogger(__name__)
 FREQ_RAW: str = "raw"
 FREQ_FIRST: str = "first"
 FREQ_LAST: str = "last"
-PD_FREQ_MNEMONICS: Dict[str, str] = {
+PD_FREQ_MNEMONICS: dict[str, str] = {
     "daily": "D",
     "weekly": "W-MON",
     "monthly": "MS",
@@ -38,10 +38,12 @@ PD_FREQ_MNEMONICS: Dict[str, str] = {
 """Mapping from res2df custom offset strings to Pandas DateOffset strings.
 See
 https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#dateoffset-objects
-"""  # noqa
+"""
 
 
-def date_range(start_date: dt.date, end_date: dt.date, freq: str) -> List[dt.datetime]:
+def date_range(
+    start_date: dt.date, end_date: dt.date, freq: str
+) -> Iterable[dt.datetime]:
     """Wrapper for pandas.date_range to allow for extra res2df specific mnemonics
     'yearly', 'daily', 'weekly', mapped over to pandas DateOffsets.
 
@@ -62,7 +64,7 @@ def date_range(start_date: dt.date, end_date: dt.date, freq: str) -> List[dt.dat
         return _fallback_date_range(start_date, end_date, freq)
 
 
-def _ensure_date_or_none(some_date: Optional[Union[str, dt.date]]) -> Optional[dt.date]:
+def _ensure_date_or_none(some_date: str | dt.date | None) -> dt.date | None:
     """Ensures an object is either a date or None
 
     Args:
@@ -83,11 +85,11 @@ def _ensure_date_or_none(some_date: Optional[Union[str, dt.date]]) -> Optional[d
 
 
 def _crop_datelist(
-    summarydates: List[dt.datetime],
-    freq: Union[dt.date, dt.datetime, str],
-    start_date: Optional[dt.date] = None,
-    end_date: Optional[dt.date] = None,
-) -> Union[List[dt.date], List[dt.datetime]]:
+    summarydates: list[dt.datetime],
+    freq: dt.date | dt.datetime | str,
+    start_date: dt.date | None = None,
+    end_date: dt.date | None = None,
+) -> list[dt.date] | list[dt.datetime]:
     """Helper function for resample_smry_dates, taking care of
     the special cases where the list of dates should not be resampled, but
     only cropped or returned as is.
@@ -102,7 +104,7 @@ def _crop_datelist(
     Returns:
         list of datetimes.
     """
-    datetimes: Union[List[dt.date], List[dt.datetime]] = []  # type: ignore
+    datetimes: list[dt.date] | list[dt.datetime] = []  # type: ignore
     if freq == FREQ_RAW:
         datetimes = summarydates
         datetimes.sort()
@@ -110,7 +112,7 @@ def _crop_datelist(
             # Convert to datetime (at 00:00:00)
             start_date = dt.datetime.combine(start_date, dt.datetime.min.time())
             datetimes = [x for x in datetimes if x > start_date]
-            datetimes = [start_date] + datetimes
+            datetimes = [start_date, *datetimes]
         if end_date:
             end_date = dt.datetime.combine(end_date, dt.datetime.min.time())
             datetimes = [x for x in datetimes if x < end_date]
@@ -162,7 +164,7 @@ def _fallback_date_roll(rollme: dt.datetime, direction: str, freq: str) -> dt.da
     )
 
 
-def _fallback_date_range(start: dt.date, end: dt.date, freq: str) -> List[dt.datetime]:
+def _fallback_date_range(start: dt.date, end: dt.date, freq: str) -> list[dt.datetime]:
     """Fallback routine for generating date ranges beyond Pandas datetime64[ns]
     year-2262 limit.
 
@@ -192,12 +194,12 @@ def _fallback_date_range(start: dt.date, end: dt.date, freq: str) -> List[dt.dat
 
 
 def resample_smry_dates(
-    summarydates: List[dt.datetime],
+    summarydates: list[dt.datetime],
     freq: str = FREQ_RAW,
     normalize: bool = True,
-    start_date: Optional[Union[str, dt.date]] = None,
-    end_date: Optional[Union[str, dt.date]] = None,
-) -> Union[List[dt.date], List[dt.datetime]]:
+    start_date: str | dt.date | None = None,
+    end_date: str | dt.date | None = None,
+) -> list[dt.date] | list[dt.datetime]:
     """
     Resample (optionally) a list of date(time)s to a new datelist according to options.
 
@@ -252,12 +254,12 @@ def resample_smry_dates(
     # For yearly frequency it will return [1997-01-01, 2021-01-01].
     offset = pd.tseries.frequencies.to_offset(PD_FREQ_MNEMONICS.get(freq, freq))
     try:
-        start_normalized = offset.rollback(start_smry.date()).date()
+        start_normalized = offset.rollback(start_smry).date()
     except pd.errors.OutOfBoundsDatetime:
         # Pandas only supports datetime up to year 2262
         start_normalized = _fallback_date_roll(start_smry, "back", freq).date()
     try:
-        end_normalized = offset.rollforward(end_smry.date()).date()
+        end_normalized = offset.rollforward(end_smry).date()
     except pd.errors.OutOfBoundsDatetime:
         # Pandas only supports datetime up to year 2262
         end_normalized = _fallback_date_roll(end_smry, "forward", freq).date()
@@ -283,7 +285,7 @@ def resample_smry_dates(
     # fit on frequency boundary. Force include these if
     # supplied as user arguments.
     if start_date and start_date not in dates:
-        dates = [start_date] + dates
+        dates = [start_date, *dates]
     if end_date and end_date not in dates:
         dates += [end_date]
     return dates
@@ -291,16 +293,15 @@ def resample_smry_dates(
 
 def df(
     resdatafiles: ResdataFiles,
-    time_index: Optional[str] = None,
-    column_keys: Optional[Union[List[str], str]] = None,
-    start_date: Optional[Union[str, dt.date]] = None,
-    end_date: Optional[Union[str, dt.date]] = None,
+    time_index: str | None = None,
+    column_keys: list[str] | str | None = None,
+    start_date: str | dt.date | None = None,
+    end_date: str | dt.date | None = None,
     include_restart: bool = False,
     params: bool = False,
-    paramfile: Optional[str] = None,
+    paramfile: str | None = None,
     datetime: bool = False,  # A very poor choice of argument name [pylint]
 ):
-    # pylint: disable=too-many-arguments
     """
     Extract data from UNSMRY as Pandas dataframes.
 
@@ -356,7 +357,7 @@ def df(
             logger.warning("Error reading summary instance, returning empty dataframe")
             return pd.DataFrame()
 
-    time_index_arg: Optional[Union[List[dt.date], List[dt.datetime]]]
+    time_index_arg: list[dt.date] | list[dt.datetime] | None
     if isinstance(time_index, str) and time_index == "raw":
         time_index_arg = resample_smry_dates(
             summary.dates,
@@ -483,7 +484,7 @@ def _ensure_unique_datetime_index(dframe: pd.DataFrame) -> pd.DataFrame:
     return dframe
 
 
-def _df2pyarrow(dframe: pd.DataFrame) -> pyarrow.Table:
+def _df2pyarrow(dframe: pd.DataFrame) -> pa.Table:
     """Construct a Pyarrow table from a dataframe, conserving metadata.
 
     All integer columns will have datatype int32, all floats will have float32
@@ -497,11 +498,11 @@ def _df2pyarrow(dframe: pd.DataFrame) -> pyarrow.Table:
     This index is always named DATE in the pyarrow table.
     """
 
-    field_list: List[pyarrow.Field] = []
-    field_list.append(pyarrow.field("DATE", pyarrow.timestamp("ms")))
+    field_list: list[pa.Field] = []
+    field_list.append(pa.field("DATE", pa.timestamp("ms")))
     column_arrays = [dframe.index.to_numpy().astype("datetime64[ms]")]
 
-    dframe_values = dframe.values.transpose()
+    dframe_values = dframe.to_numpy().transpose()
     for col_idx, colname in enumerate(dframe.columns):
         if "meta" in dframe.attrs and colname in dframe.attrs["meta"]:
             # Boolean objects in the metadata dictionary must be converted to bytes:
@@ -512,24 +513,24 @@ def _df2pyarrow(dframe: pd.DataFrame) -> pyarrow.Table:
         else:
             field_metadata = {}
         if pd.api.types.is_integer_dtype(dframe.dtypes[colname]):
-            dtype = pyarrow.int32()
+            dtype = pa.int32()
         elif pd.api.types.is_string_dtype(dframe.dtypes[colname]):
             # Parameters are potentially merged into the dataframe.
-            dtype = pyarrow.string()
+            dtype = pa.string()
         else:
-            dtype = pyarrow.float32()
-        field_list.append(pyarrow.field(colname, dtype, metadata=field_metadata))
+            dtype = pa.float32()
+        field_list.append(pa.field(colname, dtype, metadata=field_metadata))
         column_arrays.append(dframe_values[col_idx])
 
-    schema = pyarrow.schema(field_list)
+    schema = pa.schema(field_list)
 
-    return pyarrow.table(column_arrays, schema=schema)
+    return pa.table(column_arrays, schema=schema)
 
 
 def _merge_params(
     dframe: pd.DataFrame,
-    paramfile: Optional[Union[str, Path]] = None,
-    resdatafiles: Optional[Union[str, ResdataFiles]] = None,
+    paramfile: str | Path | None = None,
+    resdatafiles: str | ResdataFiles | None = None,
 ) -> pd.DataFrame:
     """Locate parameters in a <key> <value> file and add to the dataframe.
 
@@ -539,7 +540,7 @@ def _merge_params(
 
     if paramfile is None and resdatafiles is not None:
         param_files = find_parameter_files(resdatafiles)
-        logger.info("Loading parameters from files: %s", str(param_files))
+        logger.info("Loading parameters from files: %s", param_files)
         param_dict = load_all(param_files)
     elif (
         paramfile is not None
@@ -547,10 +548,10 @@ def _merge_params(
         and not Path(paramfile).is_absolute()
     ):
         param_files = find_parameter_files(resdatafiles, filebase=str(paramfile))
-        logger.info("Loading parameters from files: %s", str(param_files))
+        logger.info("Loading parameters from files: %s", param_files)
         param_dict = load_all(param_files)
     elif paramfile is not None and Path(paramfile).is_absolute():
-        logger.info("Loading parameters from file: %s", str(paramfile))
+        logger.info("Loading parameters from file: %s", paramfile)
         param_dict = load(paramfile)
     else:
         raise ValueError("Not able to locate parameters.txt")
@@ -564,7 +565,7 @@ def _merge_params(
     return dframe
 
 
-def smry_meta(resdatafiles: ResdataFiles) -> Dict[str, Dict[str, Any]]:
+def smry_meta(resdatafiles: ResdataFiles) -> dict[str, dict[str, Any]]:
     """Provide metadata for summary data vectors.
 
     A dictionary indexed by summary vector name is returned, and each
@@ -584,7 +585,7 @@ def smry_meta(resdatafiles: ResdataFiles) -> Dict[str, Dict[str, Any]]:
     else:
         summary = resdatafiles.get_summary()
 
-    meta: Dict[str, Dict[str, Any]] = {}
+    meta: dict[str, dict[str, Any]] = {}
     for col in summary:
         meta[col] = {}
         meta[col]["unit"] = summary.unit(col)
@@ -618,7 +619,7 @@ def _fix_dframe_for_resdata(dframe: pd.DataFrame) -> pd.DataFrame:
     dframe = dframe.copy()
     if "DATE" in dframe.columns:
         # Infer datatype (Pandas cannot answer it) based on the first element:
-        if isinstance(dframe["DATE"].values[0], str):
+        if isinstance(dframe["DATE"].to_numpy()[0], str):
             # Do not use pd.Series.apply() here, Pandas would try to convert it to
             # datetime64[ns] which is limited at year 2262.
             dframe["DATE"] = pd.Series(
@@ -629,7 +630,7 @@ def _fix_dframe_for_resdata(dframe: pd.DataFrame) -> pd.DataFrame:
                 dtype="object",
                 index=dframe.index,
             )
-        if isinstance(dframe["DATE"].values[0], dt.date):
+        if isinstance(dframe["DATE"].to_numpy()[0], dt.date):
             dframe["DATE"] = pd.Series(
                 [
                     dt.datetime.combine(dateobj, dt.datetime.min.time())
@@ -639,20 +640,20 @@ def _fix_dframe_for_resdata(dframe: pd.DataFrame) -> pd.DataFrame:
                 index=dframe.index,
             )
 
-        dframe.set_index("DATE", inplace=True)
+        dframe = dframe.set_index("DATE")
     if not isinstance(
-        dframe.index.values[0], (dt.datetime, np.datetime64, pd.Timestamp)
+        dframe.index.to_numpy()[0], (dt.datetime, np.datetime64, pd.Timestamp)
     ):
         raise ValueError(
             "dataframe must have a datetime index, got "
-            f"{dframe.index.values[0]} of type {type(dframe.index.values[0])}"
+            f"{dframe.index.to_numpy()[0]} of type {type(dframe.index.to_numpy()[0])}"
         )
-    dframe.sort_index(axis=0, inplace=True)
+    dframe = dframe.sort_index(axis=0)
 
     # This column will appear if dataframes are naively written to CSV
     # files and read back in again.
     if "Unnamed: 0" in dframe:
-        dframe.drop("Unnamed: 0", axis="columns", inplace=True)
+        dframe = dframe.drop("Unnamed: 0", axis="columns")
 
     block_columns = [
         col for col in dframe.columns if (col.startswith("B") or col.startswith("LB"))
@@ -661,7 +662,7 @@ def _fix_dframe_for_resdata(dframe: pd.DataFrame) -> pd.DataFrame:
         dframe = dframe.drop(columns=block_columns)
         logger.warning(
             "Dropped columns with block data, not supported: %s",
-            str({colname.partition(":")[0] + ":*" for colname in block_columns}),
+            {colname.partition(":")[0] + ":*" for colname in block_columns},
         )
 
     return dframe
@@ -795,9 +796,7 @@ def fill_reverse_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentPar
 
 def summary_main(args) -> None:
     """Read summary data from disk and write CSV back to disk"""
-    logger = getLogger_res2csv(  # pylint: disable=redefined-outer-name
-        __name__, vars(args)
-    )
+    logger = getLogger_res2csv(__name__, vars(args))
     eclbase = (
         args.DATAFILE.replace(".DATA", "").replace(".UNSMRY", "").replace(".SMSPEC", "")
     )
@@ -827,9 +826,7 @@ def summary_main(args) -> None:
 
 def summary_reverse_main(args) -> None:
     """Entry point for usage with "csv2res summary" on the command line"""
-    logger = getLogger_res2csv(  # pylint: disable=redefined-outer-name
-        __name__, vars(args)
-    )
+    logger = getLogger_res2csv(__name__, vars(args))
 
     summary_df = pd.read_csv(args.csvfile)
     logger.info("Parsed %s", args.csvfile)

res2df/trans.py

@@ -5,8 +5,8 @@ Extract transmissibility information from output files as Dataframes.
 
 import argparse
 import logging
-from typing import List, Optional, Union
 
+import networkx
 import pandas as pd
 
 from .common import write_dframe_stdout_file
@@ -15,19 +15,12 @@ from .nnc import df as create_nnc_df
 from .res2csvlogger import getLogger_res2csv
 from .resdatafiles import ResdataFiles
 
-try:
-    import networkx
-
-    HAVE_NETWORKX = True
-except ImportError:
-    HAVE_NETWORKX = False
-
 logger = logging.getLogger(__name__)
 
 
 def df(
     resdatafiles: ResdataFiles,
-    vectors: Optional[Union[str, List[str]]] = None,
+    vectors: str | list[str] | None = None,
     boundaryfilter: bool = False,
     group: bool = False,
     coords: bool = False,
@@ -105,15 +98,13 @@ def df(
     existing_vectors = [vec for vec in vectors if vec in grid_df.columns]
     if len(existing_vectors) < len(vectors):
         logger.warning(
-            "Vectors %s not found, skipping", str(set(vectors) - set(existing_vectors))
+            "Vectors %s not found, skipping", set(vectors) - set(existing_vectors)
         )
     vectors = existing_vectors
     logger.info("Building transmissibility dataframe")
     if not onlykdir:
         tranx = pd.DataFrame(grid_df[grid_df["TRANX"] > 0][["I", "J", "K", "TRANX"]])
-        tranx.rename(
-            columns={"I": "I1", "J": "J1", "K": "K1", "TRANX": "TRAN"}, inplace=True
-        )
+        tranx = tranx.rename(columns={"I": "I1", "J": "J1", "K": "K1", "TRANX": "TRAN"})
         tranx["I2"] = tranx["I1"] + 1
         tranx["J2"] = tranx["J1"]
         tranx["K2"] = tranx["K1"]
@@ -123,9 +114,7 @@ def df(
 
     if not onlykdir:
         trany = pd.DataFrame(grid_df[grid_df["TRANY"] > 0][["I", "J", "K", "TRANY"]])
-        trany.rename(
-            columns={"I": "I1", "J": "J1", "K": "K1", "TRANY": "TRAN"}, inplace=True
-        )
+        trany = trany.rename(columns={"I": "I1", "J": "J1", "K": "K1", "TRANY": "TRAN"})
         trany["I2"] = trany["I1"]
         trany["J2"] = trany["J1"] + 1
         trany["K2"] = trany["K1"]
@@ -135,9 +124,7 @@ def df(
 
     if not onlyijdir:
         tranz = pd.DataFrame(grid_df[grid_df["TRANZ"] > 0][["I", "J", "K", "TRANZ"]])
-        tranz.rename(
-            columns={"I": "I1", "J": "J1", "K": "K1", "TRANZ": "TRAN"}, inplace=True
-        )
+        tranz = tranz.rename(columns={"I": "I1", "J": "J1", "K": "K1", "TRANZ": "TRAN"})
         tranz["I2"] = tranz["I1"]
         tranz["J2"] = tranz["J1"]
         tranz["K2"] = tranz["K1"] + 1
@@ -164,18 +151,16 @@ def df(
             vectorscoords.append("Z")
 
     if vectorscoords:
-        logger.info("Adding vectors %s", str(vectorscoords))
+        logger.info("Adding vectors %s", vectorscoords)
         grid_df = grid_df.reset_index()
-        trans_df = pd.merge(
-            trans_df,
-            grid_df[["I", "J", "K"] + vectorscoords],
+        trans_df = trans_df.merge(
+            grid_df[["I", "J", "K", *vectorscoords]],
             left_on=["I1", "J1", "K1"],
             right_on=["I", "J", "K"],
         )
         trans_df = trans_df.drop(["I", "J", "K"], axis=1)
-        trans_df = pd.merge(
-            trans_df,
-            grid_df[["I", "J", "K"] + vectorscoords],
+        trans_df = trans_df.merge(
+            grid_df[["I", "J", "K", *vectorscoords]],
             left_on=["I2", "J2", "K2"],
             right_on=["I", "J", "K"],
             suffixes=("1", "2"),
@@ -203,7 +188,7 @@ def df(
     if group:
         assert len(vectors) == 1  # This is checked above
         assert boundaryfilter
-        logger.info("Grouping transmissiblity over %s interfaces", str(vectors[0]))
+        logger.info("Grouping transmissiblity over %s interfaces", vectors[0])
         vec1 = vectors[0] + "1"
         vec2 = vectors[0] + "2"
         pairname = vectors[0] + "PAIR"
@@ -236,19 +221,14 @@ def df(
     return trans_df
 
 
-def make_nx_graph(
-    resdatafiles: ResdataFiles, region: str = "FIPNUM"
-) -> "networkx.Graph":
+def make_nx_graph(resdatafiles: ResdataFiles, region: str = "FIPNUM") -> networkx.Graph:
     """Construct a networkx graph for the transmissibilities."""
-    if not HAVE_NETWORKX:
-        logger.error("Please install networkx for this function to work")
-        return None
     trans_df = df(resdatafiles, vectors=[region], coords=True, group=True)
     reg1 = region + "1"
     reg2 = region + "2"
-    graph = networkx.Graph()
+    graph: networkx.Graph = networkx.Graph()
     graph.add_weighted_edges_from(
-        [tuple(row) for row in trans_df[[reg1, reg2, "TRAN"]].values]
+        [tuple(row) for row in trans_df[[reg1, reg2, "TRAN"]].to_numpy()]
     )
     return graph
 
@@ -306,9 +286,7 @@ def fill_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
 
 def trans_main(args):
     """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)
     trans_df = df(
         resdatafiles,

res2df/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.3.7'
-__version_tuple__ = version_tuple = (1, 3, 7)
+__version__ = version = '1.3.9'
+__version_tuple__ = version_tuple = (1, 3, 9)
 
 __commit_id__ = commit_id = None

res2df/vfp/__init__.py

@@ -2,7 +2,7 @@
 keywords in Eclipse.
 """
 
-from ._vfp import (  # noqa F:401
+from ._vfp import (  # noqa: F401
     basic_data,
     basic_data2df,
     basic_data2pyarrow,