res2df 1.3.6__py3-none-any.whl → 1.3.8__py3-none-any.whl

res2df/__init__.py

@@ -1,11 +1,10 @@
 import importlib
-from typing import List
 
 from .__version__ import __version__ as __version__
 from .res2csvlogger import getLogger_res2csv as getLogger_res2csv
 from .resdatafiles import ResdataFiles as ResdataFiles
 
-SUBMODULES: List[str] = [
+SUBMODULES: list[str] = [
     "compdat",
     "equil",
     "faults",
@@ -26,5 +25,5 @@ SUBMODULES: List[str] = [
 ]
 
 
-for submodule in SUBMODULES + ["res2csv", "csv2res"]:
+for submodule in [*SUBMODULES, "res2csv", "csv2res"]:
     importlib.import_module("res2df." + submodule)

res2df/common.py

@@ -11,21 +11,24 @@ import shlex
 import signal
 import sys
 from collections import defaultdict
+from importlib import resources
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, cast
 
 import dateutil.parser
 import numpy as np
 import pandas as pd
-import pyarrow
+import pyarrow as pa
+from pyarrow import (
+    feather,  # necessary as this module is not loaded unless explicitly imported
+)
 
 try:
-    # pylint: disable=unused-import
-    import opm.io.deck  # lgtm [py/import-and-import-from]
+    import opm.io.deck
 
     # This import is seemingly not used, but necessary for some attributes
     # to be included in DeckItem objects.
-    from opm.io.deck import DeckKeyword  # noqa
+    from opm.io.deck import DeckKeyword  # noqa: F401
 except ImportError:
     # Allow parts of res2df to work without OPM:
     pass
@@ -35,7 +38,7 @@ from .constants import MAGIC_STDOUT
 
 # Parse named JSON files, this exposes a dict of dictionary describing the contents
 # of supported keyword data
-OPMKEYWORDS: Dict[str, dict] = {}
+OPMKEYWORDS: dict[str, dict] = {}
 for keyw in [
     "BRANPROP",
     "COMPDAT",
@@ -82,14 +85,14 @@ for keyw in [
     "WSEGVALV",
 ]:
     OPMKEYWORDS[keyw] = json.loads(
-        (Path(__file__).parent / "opmkeywords" / keyw).read_text()
+        (resources.files(__package__) / "opmkeywords" / keyw).read_text()
     )
 
 
 SVG_COLOR_NAMES = [
     color.lower()
     for color in (
-        (Path(__file__).parent / "svg_color_keyword_names.txt")
+        (resources.files(__package__) / "svg_color_keyword_names.txt")
         .read_text(encoding="utf-8")
         .splitlines()
     )
@@ -115,11 +118,11 @@ logger: logging.Logger = logging.getLogger(__name__)
 
 
 def write_dframe_stdout_file(
-    dframe: Union[pd.DataFrame, pyarrow.Table],
+    dframe: pd.DataFrame | pa.Table,
     output: str,
     index: bool = False,
-    caller_logger: Optional[logging.Logger] = None,
-    logstr: Optional[str] = None,
+    caller_logger: logging.Logger | None = None,
+    logstr: str | None = None,
 ) -> None:
     """Write a dataframe to either stdout or a file
 
@@ -144,13 +147,13 @@ def write_dframe_stdout_file(
         if caller_logger and isinstance(dframe, pd.DataFrame) and dframe.empty:
             caller_logger.warning("Empty dataframe being written to disk")
         if caller_logger and not logstr:
-            caller_logger.info("Writing to file %s", str(output))
+            caller_logger.info("Writing to file %s", output)
         elif caller_logger and logstr:
             caller_logger.info(logstr)
         if isinstance(dframe, pd.DataFrame):
             dframe.to_csv(output, index=index)
         else:
-            pyarrow.feather.write_feather(dframe, dest=output)
+            feather.write_feather(dframe, dest=output)
 
 
 def write_inc_stdout_file(string: str, outputfilename: str) -> None:
@@ -170,13 +173,13 @@ def parse_month(rdmonth: str) -> int:
     return MONTH2NUM[rdmonth]
 
 
-def datetime_to_ecldate(timestamp: Union[str, datetime.datetime, datetime.date]) -> str:
+def datetime_to_ecldate(timestamp: str | datetime.datetime | datetime.date) -> str:
     """Convert a Python timestamp or date to the Eclipse DATE format"""
     if isinstance(timestamp, str):
         if list(map(len, timestamp.split(" ")[0].split("-"))) != [4, 2, 2]:
             # Need this as dateutil.parser.isoparse() is not in Python 3.6.
             raise ValueError("Use ISO-format for dates")
-        timestamp = dateutil.parser.parse(timestamp)  # noqa  (py36 flake8 bug)
+        timestamp = dateutil.parser.parse(timestamp)
     if not isinstance(timestamp, (datetime.datetime, datetime.date)):
         raise TypeError("Require string or datetime")
     string = f"{timestamp.day} '{NUM2MONTH[timestamp.month]}' {timestamp.year}"
@@ -188,9 +191,9 @@ def datetime_to_ecldate(timestamp: Union[str, datetime.datetime, datetime.date])
 def keyworddata_to_df(
     deck,
     keyword: str,
-    renamer: Optional[Dict[str, Union[str, List[str]]]] = None,
-    recordcountername: Optional[str] = None,
-    emptyrecordcountername: Optional[str] = None,
+    renamer: dict[str, str | list[str]] | None = None,
+    recordcountername: str | None = None,
+    emptyrecordcountername: str | None = None,
 ) -> pd.DataFrame:
     """Extract data associated to a keyword into tabular form.
 
@@ -212,8 +215,8 @@ def keyworddata_to_df(
             row based on how many empty records is encountered. For PVTO f.ex,
             this gives the PVTNUM indexing.
     """
-    records = []  # list of dicts or dataframes
-
+    dict_records: list[dict[str, Any]] = []
+    df_records: list[pd.DataFrame] = []
     record_counter = 1
     emptyrecord_counter = 1
     for deckrecord in deck[keyword]:
@@ -235,41 +238,45 @@ def keyworddata_to_df(
         if "DATA" in recdict and isinstance(recdict["DATA"], list):
             assert renamer is not None
             # If DATA is sometimes used for something else in the jsons, redo this.
-            data_dim = len(renamer["DATA"])  # The renamers must be in sync with json!
+            renamed_data = renamer.get("DATA", [])
+            if isinstance(renamed_data, str):
+                renamed_data = [renamed_data]
+            data_dim = len(renamed_data)  # The renamers must be in sync with json!
             data_chunks = int(len(recdict["DATA"]) / data_dim)
             try:
                 data_reshaped = np.reshape(recdict["DATA"], (data_chunks, data_dim))
             except ValueError as err:
                 raise ValueError(
-                    (
-                        f"Wrong number count for keyword {keyword}. \n"
-                        "Either your keyword is wrong, or your data is wrong"
-                    )
+                    f"Wrong number count for keyword {keyword}. \n"
+                    "Either your keyword is wrong, or your data is wrong"
                 ) from err
-            data_df = pd.DataFrame(columns=renamer["DATA"], data=data_reshaped)
+            data_df = pd.DataFrame(columns=renamed_data, data=data_reshaped)
             # Assign the remaining items from the parsed dict to the dataframe:
             for key, value in recdict.items():
                 if key != "DATA":
                     data_df[key] = value
-            records.append(data_df)
-            record_counter += 1
+            df_records.append(data_df)
         else:
-            records.append(recdict)
-            record_counter += 1
-    if isinstance(records[0], pd.DataFrame):
-        dframe = pd.concat(records)
-    else:  # records contain lists.
-        dframe = pd.DataFrame(data=records)
-    return dframe.reset_index(drop=True)
+            dict_records.append(recdict)
+        record_counter += 1
+    if df_records and dict_records:
+        dict_df = pd.DataFrame(data=dict_records)
+        return pd.concat([*df_records, dict_df]).reset_index(drop=True)
+    elif df_records:  # trust that this is all one type?
+        return pd.concat(df_records).reset_index(drop=True)
+    elif dict_records:  # records contain lists.
+        return pd.DataFrame(data=dict_records).reset_index(drop=True)
+    else:
+        return pd.DataFrame()
 
 
 def parse_opmio_deckrecord(
-    record: "opm.libopmcommon_python.DeckRecord",
+    record: "opm.opmcommon_python.DeckRecord",
     keyword: str,
     itemlistname: str = "items",
-    recordindex: Optional[int] = None,
-    renamer: Optional[Union[Dict[str, str], Dict[str, Union[str, List[str]]]]] = None,
-) -> Dict[str, Any]:
+    recordindex: int | None = None,
+    renamer: dict[str, str] | dict[str, str | list[str]] | None = None,
+) -> dict[str, Any]:
     """
     Parse an opm.io.DeckRecord belonging to a certain keyword
 
@@ -289,7 +296,7 @@ def parse_opmio_deckrecord(
     if keyword not in OPMKEYWORDS:
         raise ValueError(f"Keyword {keyword} not supported by common.py")
 
-    rec_dict: Dict[str, Any] = {}
+    rec_dict: dict[str, Any] = {}
 
     if recordindex is None:  # Beware, 0 is different from None here.
         itemlist = OPMKEYWORDS[keyword][itemlistname]
@@ -329,14 +336,13 @@ def parse_opmio_deckrecord(
                     # OPM DeckItem. A better solution has not yet
                     # been found in the OPM API. See also
                     # https://github.com/OPM/opm-common/issues/2598
-                    # pylint: disable=protected-access
                     if record[item_idx].__defaulted(idx):
                         rec_dict[item_name][idx] = np.nan
         else:
             rec_dict[item_name] = jsonitem.get("default", None)
 
     if renamer:
-        renamed_dict: Dict[str, Any] = {}
+        renamed_dict: dict[str, Any] = {}
         for key, value in rec_dict.items():
             if key in renamer and not isinstance(renamer[key], list):
                 renamed_dict[renamer[key]] = value  # type: ignore
@@ -354,7 +360,7 @@ def parse_opmio_date_rec(record: "opm.io.DeckRecord") -> datetime.date:
     return datetime.date(year=year, month=parse_month(month), day=day)
 
 
-def parse_opmio_tstep_rec(record: "opm.io.DeckRecord") -> List[Union[float, int]]:
+def parse_opmio_tstep_rec(record: "opm.io.DeckRecord") -> list[float | int]:
     """Parse a record with TSTEP data
 
     Return:
@@ -396,13 +402,13 @@ def merge_zones(
         return df
     zone_df = pd.DataFrame.from_dict(zonedict, orient="index", columns=[zoneheader])
     zone_df.index.name = "K"
-    zone_df.reset_index(inplace=True)
+    zone_df = zone_df.reset_index()
 
     df[zoneheader] = df[kname].map(defaultdict(lambda: None, zonedict))
     return df
 
 
-def comment_formatter(multiline: Optional[str], prefix: str = "-- ") -> str:
+def comment_formatter(multiline: str | None, prefix: str = "-- ") -> str:
     """Prepends comment characters to every line in input
 
     If nothing is supplied, an empty string is returned.
@@ -422,11 +428,11 @@ def comment_formatter(multiline: Optional[str], prefix: str = "-- ") -> str:
 
 
 def handle_wanted_keywords(
-    wanted: Optional[List[str]],
+    wanted: list[str] | None,
     deck: "opm.io.Deck",
-    supported: List[str],
+    supported: list[str],
     modulename: str = "",
-) -> List[str]:
+) -> list[str]:
     """Handle three list of keywords, wanted, available and supported
 
     Args:
@@ -442,12 +448,12 @@ def handle_wanted_keywords(
         keywords = supported
     else:
         # Warn if some keywords are unsupported:
-        not_supported: Set[str] = set(wanted) - set(supported)
+        not_supported: set[str] = set(wanted) - set(supported)
         if not_supported:
             logger.warning(
                 "Requested keyword(s) not supported by res2df.%s: %s",
                 modulename,
-                str(not_supported),
+                not_supported,
             )
         # Reduce to only supported keywords:
         keywords = list(set(wanted) - set(not_supported))
@@ -455,9 +461,7 @@ def handle_wanted_keywords(
         keywords_in_deck = [keyword for keyword in keywords if keyword in deck]
         not_in_deck = set(keywords) - set(keywords_in_deck)
         if not_in_deck:
-            logger.warning(
-                "Requested keyword(s) not present in deck: %s", str(not_in_deck)
-            )
+            logger.warning("Requested keyword(s) not present in deck: %s", not_in_deck)
     # Reduce again to only present keywords, but without warning:
     keywords = [keyword for keyword in keywords if keyword in deck]
 
@@ -506,11 +510,11 @@ def fill_reverse_parser(
 
 def df2res(
     dataframe: pd.DataFrame,
-    keywords: Optional[Union[str, List[str], List[Optional[str]]]] = None,
-    comments: Optional[Dict[str, str]] = None,
-    supported: Optional[List[str]] = None,
-    consecutive: Optional[str] = None,
-    filename: Optional[str] = None,
+    keywords: str | list[str] | list[str | None] | None = None,
+    comments: dict[str, str] | None = None,
+    supported: list[str] | None = None,
+    consecutive: str | None = None,
+    filename: str | None = None,
 ) -> str:
     """Generate resdata :term:`include file` content from dataframes in res2df format.
 
@@ -552,7 +556,7 @@ def df2res(
         logger.critical(
             "%s inconsistent in input dataframe, got the values %s",
             consecutive,
-            str(dataframe[consecutive].unique()),
+            dataframe[consecutive].unique(),
         )
         raise ValueError
 
@@ -572,18 +576,18 @@ def df2res(
         # Warn if some keywords are unsupported:
         assert keywords is not None
         assert supported is not None
-        not_supported: Set[Optional[str]] = set(keywords) - set(supported)
+        not_supported: set[str | None] = set(keywords) - set(supported)
         if not_supported:
             logger.warning(
                 "Requested keyword(s) not supported by %s: %s",
                 calling_module.__name__,  # type: ignore
-                str(not_supported),
+                not_supported,
             )
         # Warn if some requested keywords are not in frame:
         not_in_frame = set(keywords) - keywords_in_frame
         if not_in_frame:
             logger.warning(
-                "Requested keyword(s) not present in dataframe: %s", str(not_in_frame)
+                "Requested keyword(s) not present in dataframe: %s", not_in_frame
             )
     keywords = [
         keyword
@@ -626,8 +630,8 @@ def df2res(
 def generic_deck_table(
     dframe: pd.DataFrame,
     keyword: str,
-    comment: Optional[str] = None,
-    renamer: Optional[Dict[str, str]] = None,
+    comment: str | None = None,
+    renamer: dict[str, str] | None = None,
     drop_trailing_columns: bool = True,
 ) -> str:
     """Construct string contents of a :term:`.DATA file` table.
@@ -666,7 +670,7 @@ def generic_deck_table(
     # sorting from that:
     if renamer is not None:
         inv_renamer = {value: key for key, value in renamer.items()}
-        dframe.rename(inv_renamer, axis="columns", inplace=True)
+        dframe = dframe.rename(inv_renamer, axis="columns")
 
     keyword_col_headers = [item["name"] for item in OPMKEYWORDS[keyword]["items"]]
 
@@ -680,7 +684,7 @@ def generic_deck_table(
     if rightmost_column == -1:
         # No relevant data in the dataframe
         return string
-    relevant_columns = keyword_col_headers[0 : rightmost_column + 1]  # noqa
+    relevant_columns = keyword_col_headers[0 : rightmost_column + 1]
     for colname in relevant_columns:
         # Add those that are missing, as Eclipse defaults
         if colname not in dframe:
@@ -731,7 +735,7 @@ def generic_deck_table(
 
     # Now rename again to have prettier column names:
     if renamer is not None:
-        dframe.rename(renamer, axis="columns", inplace=True)
+        dframe = dframe.rename(renamer, axis="columns")
     # Add a final column with the end-slash, invisible header:
     dframe[" "] = "/"
     tablestring = dframe.to_string(header=True, index=False)
@@ -827,13 +831,13 @@ def stack_on_colnames(
     dframe.columns = pd.MultiIndex.from_tuples(
         tuplecolumns, names=["dummy", stackcolname]
     )
-    dframe = dframe.stack(future_stack=True)
+    dframe = cast(pd.DataFrame, dframe.stack(future_stack=True))
     staticcols = [col[0] for col in tuplecolumns if len(col) == 1]
     dframe[staticcols] = dframe[staticcols].ffill()
-    dframe.reset_index(inplace=True)
+    dframe = dframe.reset_index()
     # Drop rows stemming from the NaNs in the second tuple-element for
     # static columns:
-    dframe.dropna(axis="index", subset=["DATE"], inplace=True)
+    dframe = dframe.dropna(axis="index", subset=["DATE"])
     del dframe["level_0"]
     dframe.index.name = ""
     return dframe
@@ -851,7 +855,7 @@ def is_color(input_string: str) -> bool:
     return bool(re.match(regex, input_string))
 
 
-def parse_lyrfile(filename: str) -> Optional[List[Dict[str, Any]]]:
+def parse_lyrfile(filename: str) -> list[dict[str, Any]] | None:
     """Return a list of dicts representation of the lyr file.
 
     The lyr file contains data of the following format,
@@ -885,7 +889,7 @@ def parse_lyrfile(filename: str) -> Optional[List[Dict[str, Any]]]:
     Returns:
         A list of dictionaries representing the information in the lyr file.
 
-    """  # noqa
+    """
 
     zonelines = Path(filename).read_text(encoding="utf-8").splitlines()
 
@@ -893,11 +897,11 @@ def parse_lyrfile(filename: str) -> Optional[List[Dict[str, Any]]]:
     zonelines = [line.split("--")[0].strip() for line in zonelines]
     zonelines = [line for line in zonelines if line and not line.startswith("#")]
 
-    lyrlist: List[Dict[str, Any]] = []
+    lyrlist: list[dict[str, Any]] = []
     for line in zonelines:
         try:
             linesplit = shlex.split(line)
-            zonedict: Dict[str, Any] = {"name": linesplit[0]}
+            zonedict: dict[str, Any] = {"name": linesplit[0]}
             zone_color = linesplit.pop(-1) if is_color(linesplit[-1]) else None
             if zone_color is not None:
                 zonedict["color"] = zone_color
@@ -923,7 +927,7 @@ def parse_lyrfile(filename: str) -> Optional[List[Dict[str, Any]]]:
     return lyrlist
 
 
-def convert_lyrlist_to_zonemap(lyrlist: List[Dict[str, Any]]) -> Dict[int, str]:
+def convert_lyrlist_to_zonemap(lyrlist: list[dict[str, Any]]) -> dict[int, str]:
     """Returns a layer to zone map as a dictionary
 
     Args:

res2df/compdat.py

@@ -14,13 +14,11 @@ import argparse
 import contextlib
 import datetime
 import logging
-from typing import Dict, List, Optional, Union
 
 import numpy as np
 import pandas as pd
 
 with contextlib.suppress(ImportError):
-    # pylint: disable=unused-import
     import opm.io.deck
 
 from .common import (
@@ -43,7 +41,7 @@ documentation ever so slightly different when naming the data.
 For COMPDAT dataframe columnnames, we prefer the RMS terms due to the
 one very long one, and mixed-case in opm
 """
-COMPDAT_RENAMER: Dict[str, str] = {
+COMPDAT_RENAMER: dict[str, str] = {
     "WELL": "WELL",
     "I": "I",
     "J": "J",
@@ -61,7 +59,7 @@ COMPDAT_RENAMER: Dict[str, str] = {
 }
 
 # Workaround an inconsistency in JSON-files for OPM-common < 2021.04:
-WSEG_RENAMER: Dict[str, str] = {
+WSEG_RENAMER: dict[str, str] = {
     "SEG1": "SEGMENT1",
     "SEG2": "SEGMENT2",
 }
@@ -69,9 +67,9 @@ WSEG_RENAMER: Dict[str, str] = {
 
 def deck2dfs(
     deck: "opm.io.Deck",
-    start_date: Optional[Union[str, datetime.date]] = None,
+    start_date: str | datetime.date | None = None,
     unroll: bool = True,
-) -> Dict[str, pd.DataFrame]:
+) -> dict[str, pd.DataFrame]:
     """Loop through the :term:`deck` and pick up information found
 
     The loop over the :term:`deck` is a state machine, as it has to pick up dates and
@@ -103,7 +101,7 @@ def deck2dfs(
         if kword.name in ["DATES", "START"]:
             for rec in kword:
                 date = parse_opmio_date_rec(rec)
-                logger.info("Parsing at date %s", str(date))
+                logger.info("Parsing at date %s", date)
         elif kword.name == "TSTEP":
             if not date:
                 logger.critical("Can't use TSTEP when there is no start_date")
@@ -114,9 +112,7 @@ def deck2dfs(
                 days = sum(steplist)
                 assert isinstance(date, datetime.date)
                 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)
         elif kword.name == "WELSPECS":
             # Information from WELSPECS are to be used in case
             # 0 or 1* is used in the I or J column in COMPDAT
@@ -238,7 +234,6 @@ def deck2dfs(
 
     if unroll and not compdat_df.empty:
         compdat_df = unrolldf(compdat_df, "K1", "K2")
-
     if not welopen_df.empty:
         compdat_df = applywelopen(
             compdat_df,
@@ -263,16 +258,16 @@ def deck2dfs(
         wsegaicd_df = unrolldf(wsegaicd_df, "SEGMENT1", "SEGMENT2")
 
     if "KEYWORD_IDX" in compdat_df.columns:
-        compdat_df.drop(["KEYWORD_IDX"], axis=1, inplace=True)
+        compdat_df = compdat_df.drop(["KEYWORD_IDX"], axis=1)
 
     if "KEYWORD_IDX" in wsegsicd_df.columns:
-        wsegsicd_df.drop(["KEYWORD_IDX"], axis=1, inplace=True)
+        wsegsicd_df = wsegsicd_df.drop(["KEYWORD_IDX"], axis=1)
 
     if "KEYWORD_IDX" in wsegaicd_df.columns:
-        wsegaicd_df.drop(["KEYWORD_IDX"], axis=1, inplace=True)
+        wsegaicd_df = wsegaicd_df.drop(["KEYWORD_IDX"], axis=1)
 
     if "KEYWORD_IDX" in wsegvalv_df.columns:
-        wsegvalv_df.drop(["KEYWORD_IDX"], axis=1, inplace=True)
+        wsegvalv_df = wsegvalv_df.drop(["KEYWORD_IDX"], axis=1)
 
     return {
         "COMPDAT": compdat_df,
@@ -310,7 +305,7 @@ def expand_welopen_defaults(
     to this functions.
     """
 
-    def is_default(value: Optional[int]) -> bool:
+    def is_default(value: int | None) -> bool:
         if value is None or np.isnan(value):
             return True
         return value <= 0
@@ -330,7 +325,7 @@ def expand_welopen_defaults(
 
             # Any compdat entry with DATE==None are kept as they
             # are assumed to have an earlier date than any dates defined
-            compdat_filtered = compdat_df[compdat_df["DATE"].isnull()]
+            compdat_filtered = compdat_df[compdat_df["DATE"].isna()]
 
             # If the welopen entry DATE!=None we filter on compdat entries
             # <= this date
@@ -564,7 +559,7 @@ def expand_wlist(wlist_df: pd.DataFrame) -> pd.DataFrame:
     # of dictionaries, which accumulates all WLIST directives. Every time the date
     # changes, the current state is outputted as it was valid for the previous date.
 
-    currentstate: Dict[str, str] = {}
+    currentstate: dict[str, str] = {}
 
     if wlist_df.empty:
         return wlist_df
@@ -615,7 +610,7 @@ def expand_wlist(wlist_df: pd.DataFrame) -> pd.DataFrame:
             and wlist_record["NAME"] not in currentstate
         ):
             raise ValueError(
-                f"WLIST ADD/DEL only works on existing well lists: {str(wlist_record)}"
+                f"WLIST ADD/DEL only works on existing well lists: {wlist_record!s}"
             )
         if wlist_record["ACTION"] == "ADD":
             currentstate[wlist_record["NAME"]] = " ".join(
@@ -757,7 +752,7 @@ def expand_complump_in_welopen_df(
                 exp_welopens.append(cell_row)
 
     dframe = pd.DataFrame(exp_welopens)
-    return dframe.astype(object).where(pd.notnull(dframe), None)
+    return dframe.astype(object).where(pd.notna(dframe), None)
 
 
 def expand_wlist_in_welopen_df(
@@ -783,7 +778,7 @@ def expand_wlist_in_welopen_df(
                     .split()
                 ):
                     wellrow = row.copy()
-                    wellrow.update({"WELL": well})
+                    wellrow["WELL"] = well
                     exp_welopens.append(wellrow)
             else:
                 raise ValueError(f"Well list {wlistname} not defined at {row['DATE']}")
@@ -791,14 +786,14 @@ def expand_wlist_in_welopen_df(
             # Explicit wellname was used, no expansion to happen:
             exp_welopens.append(row)
     dframe = pd.DataFrame(exp_welopens)
-    return dframe.astype(object).where(pd.notnull(dframe), None)
+    return dframe.astype(object).where(pd.notna(dframe), None)
 
 
 def applywelopen(
     compdat_df: pd.DataFrame,
     welopen_df: pd.DataFrame,
-    wlist_df: Optional[pd.DataFrame] = None,
-    complump_df: Optional[pd.DataFrame] = None,
+    wlist_df: pd.DataFrame | None = None,
+    complump_df: pd.DataFrame | None = None,
 ) -> pd.DataFrame:
     """Apply WELOPEN actions to the COMPDAT dataframe.
 
@@ -850,9 +845,11 @@ def applywelopen(
                 "The WLIST dataframe must be expanded through expand_wlist()"
             )
 
-    welopen_df = welopen_df.astype(object).where(pd.notnull(welopen_df), None)
-    welopen_df = expand_wlist_in_welopen_df(welopen_df, wlist_df)
-    welopen_df = expand_complump_in_welopen_df(welopen_df, complump_df)
+    welopen_df = welopen_df.astype(object).where(pd.notna(welopen_df), None)
+    if wlist_df is not None:
+        welopen_df = expand_wlist_in_welopen_df(welopen_df, wlist_df)
+    if complump_df is not None:
+        welopen_df = expand_complump_in_welopen_df(welopen_df, complump_df)
 
     for _, row in welopen_df.iterrows():
         acts_on_well = False
@@ -956,9 +953,7 @@ def fill_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
 
 def compdat_main(args):
     """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)
     compdat_df = df(resdatafiles, initvectors=args.initvectors)
     write_dframe_stdout_file(compdat_df, args.output, index=False, caller_logger=logger)
@@ -966,8 +961,8 @@ def compdat_main(args):
 
 def df(
     resdatafiles: ResdataFiles,
-    initvectors: Optional[List[str]] = None,
-    zonemap: Optional[Dict[int, str]] = None,
+    initvectors: list[str] | None = None,
+    zonemap: dict[int, str] | None = None,
 ) -> pd.DataFrame:
     """Main function for Python API users
 

res2df/csv2res.py

@@ -5,7 +5,6 @@ for selected keywords
 """
 
 import argparse
-import sys
 
 from .__version__ import __version__
 from .equil import equil_reverse_main
@@ -35,14 +34,11 @@ def get_parser() -> argparse.ArgumentParser:
         version=f"%(prog)s {__version__}",
     )
 
-    if sys.version_info.major >= 3 and sys.version_info.minor >= 7:
-        subparsers = parser.add_subparsers(  # type: ignore
-            required=True,
-            dest="subcommand",
-            parser_class=argparse.ArgumentParser,
-        )
-    else:
-        subparsers = parser.add_subparsers(parser_class=argparse.ArgumentParser)
+    subparsers = parser.add_subparsers(  # type: ignore
+        required=True,
+        dest="subcommand",
+        parser_class=argparse.ArgumentParser,
+    )
 
     summary_parser = subparsers.add_parser(
         "summary",