Fix all formatting-related pylint complaints under fre/, raise fail-under to 8.89

fre/__init__.py

@@ -2,12 +2,12 @@
 module init file for fre. sets the version attribute, and sets up a fre_logger
 """
 
+import logging
 import os
+
 version = os.getenv("GIT_DESCRIBE_TAG", "2025.04")
 __version__ = version
 
-import logging
-
 fre_logger = logging.getLogger(__name__)
 
 FORMAT = "[%(levelname)5s:%(filename)24s:%(funcName)24s] %(message)s"

fre/analysis/freanalysis.py

@@ -1,16 +1,19 @@
 ''' fre analysis '''
 
 # a third party package
-import click
 import logging
-fre_logger = logging.getLogger(__name__)
 
-## a diff gfdl package
-#from analysis_scripts import available_plugins
+import click
 
 # this package
-from .subtools import install_analysis_package, list_plugins, run_analysis, \
-                      uninstall_analysis_package
+from .subtools import (
+    install_analysis_package,
+    list_plugins,
+    run_analysis,
+    uninstall_analysis_package
+)
+
+fre_logger = logging.getLogger(__name__)
 
 
 @click.group(help=click.style(" - analysis subcommands", fg=(250, 154, 90)))

fre/app/generate_time_averages/combine.py

@@ -61,7 +61,7 @@
     if Path(output_file).exists():
         raise FileExistsError(f"Output file '{output_file}' already exists")
 
     ds = xr.open_mfdataset(input_files, compat='override', coords='minimal')
     ds.to_netcdf(output_file, unlimited_dims=['time'])
 
 
@@ -94,7 +94,7 @@
     """
     if frequency not in ["yr", "mon"]:
         raise ValueError(f"Frequency '{frequency}' not recognized or supported")
-    
+
     if frequency == "yr":
         frequency_iso = "P1Y"
     elif frequency == "mon":

fre/app/generate_time_averages/generate_time_averages.py

@@ -125,6 +125,3 @@ def generate(inf = None,
         fre_logger.warning('time averaging exited non-zero, exitstatus == %s', exitstatus)
     else:
         fre_logger.info('time averaging finished successfully')
-
-
-

fre/app/helpers.py

@@ -1,10 +1,12 @@
+# set up logging
+import logging
 import os
+from contextlib import contextmanager
 from pathlib import Path
+
 import yaml
-from contextlib import contextmanager
 
-# set up logging
-import logging
+
 fre_logger = logging.getLogger(__name__)
 
 def get_variables(yml: dict, pp_comp: str) -> dict:
@@ -30,7 +32,9 @@ def get_variables(yml: dict, pp_comp: str) -> dict:
     for component_info in yml["postprocess"]["components"]:
         # if component in yaml not an active pp component, skip
         if component_info.get("type") != pp_comp:
-            fre_logger.info(f'Component in pp yaml config (%s) does not match active pp component (%s). Skipping component remapping ...', component_info.get("type"), pp_comp)
+            fre_logger.info(
+                'Component in pp yaml config (%s) does not match active pp component (%s). '
+                'Skipping component remapping ...', component_info.get("type"), pp_comp)
             continue
 
         # non-static

fre/app/regrid_xy/regrid_xy.py

@@ -361,7 +361,10 @@ def regrid_xy(yamlfile: str,
                 continue
 
             # create the output dir
-            output_subdir = Path(output_dir) / f"{datadict['output_nlat']}_{datadict['output_nlon']}.{datadict['interp_method']}"
+            output_subdir = (
+                Path(output_dir)
+                / f"{datadict['output_nlat']}_{datadict['output_nlon']}.{datadict['interp_method']}"
+            )
             output_subdir.mkdir(parents=True, exist_ok=True)
 
             #construct fregrid command

fre/app/regrid_xy/tests/generate_files.py

@@ -1,9 +1,11 @@
-import numpy as np
-from pathlib import Path
 import shutil
 import tarfile
-import yaml
+from pathlib import Path
+
+import numpy as np
 import xarray as xr
+import yaml
+
 
 nxy = 20
 nxyp = nxy + 1
@@ -20,24 +22,25 @@
 
 def cleanup():
 
-  if Path(yamlfile).exists():
-    Path(yamlfile).unlink()
+    if Path(yamlfile).exists():
+        Path(yamlfile).unlink()
 
-  if Path("grid_spec.nc").exists():
-    Path("grid_spec.nc").unlink()
+    if Path("grid_spec.nc").exists():
+        Path("grid_spec.nc").unlink()
 
-  if Path(grid_spec_tar).exists():
-    Path(grid_spec_tar).unlink()
+    if Path(grid_spec_tar).exists():
+        Path(grid_spec_tar).unlink()
 
-  if Path(input_mosaic).exists():
-    Path(input_mosaic).unlink()
+    if Path(input_mosaic).exists():
+        Path(input_mosaic).unlink()
 
-  if Path(input_dir).exists():
-    shutil.rmtree(input_dir)
+    if Path(input_dir).exists():
+        shutil.rmtree(input_dir)
 
-  for i in range(1, ntiles+1):
-    gridfile = Path(f"{input_grid}.tile{i}.nc")
-    if gridfile.exists(): gridfile.unlink()
+    for i in range(1, ntiles+1):
+        gridfile = Path(f"{input_grid}.tile{i}.nc")
+        if gridfile.exists():
+            gridfile.unlink()
 
 
 def set_test(components_in: dict,
@@ -50,124 +53,132 @@ def set_test(components_in: dict,
              input_grid_in: str = None,
              input_dir_in: str = None):
 
-  global components
-  global nxyp, nxy, ntiles, grid_spec_tar, input_grid
-  global date, input_mosaic
-  global input_dir, yamlfile
-  global tar_list
-
-  components = components_in
-  if nxy_in is not None:
-    nxy = nxy_in
-    nxyp = nxy_in+1
-    input_grid = f"C{nxy}"
-  if ntiles_in is not None: ntiles = ntiles_in
-  if date_in is not None: date = date_in
-  if yamlfile_in is not None: yamlfile = yamlfile_in
-  if grid_spec_tar_in is not None: grid_spec_tar = grid_spec_tar_in
-  if input_grid_in is not None: input_grid = input_grid_in
-  if input_mosaic_in is not None: input_mosaic = input_mosaic_in
-  if input_dir_in is not None: input_dir = input_dir_in
-
-  tar_list = []
+    global components
+    global nxyp, nxy, ntiles, grid_spec_tar, input_grid
+    global date, input_mosaic
+    global input_dir, yamlfile
+    global tar_list
+
+    components = components_in
+    if nxy_in is not None:
+        nxy = nxy_in
+        nxyp = nxy_in+1
+        input_grid = f"C{nxy}"
+    if ntiles_in is not None:
+        ntiles = ntiles_in
+    if date_in is not None:
+        date = date_in
+    if yamlfile_in is not None:
+        yamlfile = yamlfile_in
+    if grid_spec_tar_in is not None:
+        grid_spec_tar = grid_spec_tar_in
+    if input_grid_in is not None:
+        input_grid = input_grid_in
+    if input_mosaic_in is not None:
+        input_mosaic = input_mosaic_in
+    if input_dir_in is not None:
+        input_dir = input_dir_in
+
+    tar_list = []
 
 def make_yaml():
 
-  ppyaml = {}
-  ppyaml["name"] = yamlfile
+    ppyaml = {}
+    ppyaml["name"] = yamlfile
 
-  directories = ppyaml["directories"] = {}
-  directories["history_dir"] = "./"
-  directories["pp_dir"] = "./"
+    directories = ppyaml["directories"] = {}
+    directories["history_dir"] = "./"
+    directories["pp_dir"] = "./"
 
-  postprocess = ppyaml["postprocess"] = {}
-  postprocess["settings"] = {"pp_grid_spec": grid_spec_tar}
-  postprocess["components"] = components
+    postprocess = ppyaml["postprocess"] = {}
+    postprocess["settings"] = {"pp_grid_spec": grid_spec_tar}
+    postprocess["components"] = components
 
-  with open(yamlfile, "w") as openedfile:
-    yaml.dump(ppyaml, openedfile, sort_keys=False)
+    with open(yamlfile, "w") as openedfile:
+        yaml.dump(ppyaml, openedfile, sort_keys=False)
 
 
 def make_grid_spec():
-  xr.Dataset(data_vars={"atm_mosaic_file": f"{input_mosaic}".encode(),
-                        "lnd_mosaic_file": f"{input_mosaic}".encode(),
-                        "ocn_mosaic_file": "ocean_mosaic.nc".encode()}
-             ).to_netcdf("grid_spec.nc")
+    xr.Dataset(data_vars={"atm_mosaic_file": f"{input_mosaic}".encode(),
+                          "lnd_mosaic_file": f"{input_mosaic}".encode(),
+                          "ocn_mosaic_file": "ocean_mosaic.nc".encode()}
+               ).to_netcdf("grid_spec.nc")
 
-  tar_list.append("grid_spec.nc")
+    tar_list.append("grid_spec.nc")
 
 
 def make_mosaic():
 
-  if ntiles > 1:
-    gridfiles = [f"{input_grid}.tile{i}.nc".encode() for i in range(1,ntiles+1)]
-    gridtiles = [f"tile{i}".encode() for i in range(1,ntiles+1)]
-  else:
-    gridfiles = f"{input_grid}.nc".encode()
-    gridtiles = f"tile1".encode()
+    if ntiles > 1:
+        gridfiles = [f"{input_grid}.tile{i}.nc".encode() for i in range(1,ntiles+1)]
+        gridtiles = [f"tile{i}".encode() for i in range(1,ntiles+1)]
+    else:
+        gridfiles = f"{input_grid}.nc".encode()
+        gridtiles = "tile1".encode()
 
-  data = dict(gridfiles =  xr.DataArray(gridfiles, dims=["ntiles"]).astype("|S255"),
-              gridtiles = xr.DataArray(gridtiles, dims=["ntiles"]).astype("|S255")
-  )
+    data = dict(gridfiles =  xr.DataArray(gridfiles, dims=["ntiles"]).astype("|S255"),
+                gridtiles = xr.DataArray(gridtiles, dims=["ntiles"]).astype("|S255")
+    )
 
-  xr.Dataset(data_vars=data).to_netcdf(f"{input_mosaic}")
+    xr.Dataset(data_vars=data).to_netcdf(f"{input_mosaic}")
 
-  tar_list.append(f"{input_mosaic}")
+    tar_list.append(f"{input_mosaic}")
 
 
 def make_grid():
 
-  xy = np.arange(0, nxyp, 1, dtype=np.float64)
-  area = np.ones((nxy, nxy), dtype=np.float64)
+    xy = np.arange(0, nxyp, 1, dtype=np.float64)
+    area = np.ones((nxy, nxy), dtype=np.float64)
 
-  x, y = np.meshgrid(xy, xy)
+    x, y = np.meshgrid(xy, xy)
 
-  data = dict(x = xr.DataArray(x, dims=["nyp", "nxp"]),
-              y = xr.DataArray(y, dims=["nyp", "nxp"]),
-              area = xr.DataArray(area, dims=["ny", "nx"])
-  )
+    data = dict(x = xr.DataArray(x, dims=["nyp", "nxp"]),
+                y = xr.DataArray(y, dims=["nyp", "nxp"]),
+                area = xr.DataArray(area, dims=["ny", "nx"])
+    )
 
-  for i in range(1, ntiles+1):
-    data["tile"] = xr.DataArray(f"tile{i}".encode()).astype("|S255")
-    xr.Dataset(data).to_netcdf(f"{input_grid}.tile{i}.nc")
+    for i in range(1, ntiles+1):
+        data["tile"] = xr.DataArray(f"tile{i}".encode()).astype("|S255")
+        xr.Dataset(data).to_netcdf(f"{input_grid}.tile{i}.nc")
 
-    tar_list.append(f"{input_grid}.tile{i}.nc")
+        tar_list.append(f"{input_grid}.tile{i}.nc")
 
 
 def make_data():
 
-  data = {}
-  data["mister"] = xr.DataArray(np.full((nxy,nxy), 1.0, dtype=np.float64), dims=["ny", "nx"])
-  data["darcy"] = xr.DataArray(np.full((nxy,nxy), 2.0, dtype=np.float64), dims=["ny", "nx"])
-  data["wins"] = xr.DataArray(np.full((nxy,nxy), 3.0, dtype=np.float64), dims=["ny", "nx"])
-  data["wet_c"] = xr.DataArray(np.full((nxy,nxy), 5.0, dtype=np.float64), dims=["ny", "nx"])
+    data = {}
+    data["mister"] = xr.DataArray(np.full((nxy,nxy), 1.0, dtype=np.float64), dims=["ny", "nx"])
+    data["darcy"] = xr.DataArray(np.full((nxy,nxy), 2.0, dtype=np.float64), dims=["ny", "nx"])
+    data["wins"] = xr.DataArray(np.full((nxy,nxy), 3.0, dtype=np.float64), dims=["ny", "nx"])
+    data["wet_c"] = xr.DataArray(np.full((nxy,nxy), 5.0, dtype=np.float64), dims=["ny", "nx"])
 
-  coords = {"nx": np.arange(1,nxyp, dtype=np.float64),
-            "ny": np.arange(1,nxyp, dtype=np.float64)}
+    coords = {"nx": np.arange(1,nxyp, dtype=np.float64),
+              "ny": np.arange(1,nxyp, dtype=np.float64)}
 
-  dataset = xr.Dataset(data_vars=data, coords=coords)
+    dataset = xr.Dataset(data_vars=data, coords=coords)
 
-  for component in components:
-    for source in component["sources"]:
-      history_file = source["history_file"]
-      for i in range(1, ntiles+1):
-        dataset.to_netcdf(f"{input_dir}/{date}.{history_file}.tile{i}.nc")
-    if "static" in component:
-      for static_source in component["static"]:
-        history_file = static_source["source"]
-        for i in range(1, ntiles+1):
-          dataset.to_netcdf(f"{input_dir}/{date}.{history_file}.tile{i}.nc")
+    for component in components:
+        for source in component["sources"]:
+            history_file = source["history_file"]
+            for i in range(1, ntiles+1):
+                dataset.to_netcdf(f"{input_dir}/{date}.{history_file}.tile{i}.nc")
+        if "static" in component:
+            for static_source in component["static"]:
+                history_file = static_source["source"]
+                for i in range(1, ntiles+1):
+                    dataset.to_netcdf(f"{input_dir}/{date}.{history_file}.tile{i}.nc")
 
 
 def make_all():
-  make_yaml()
-  make_grid_spec()
-  make_mosaic()
-  make_grid()
-  make_data()
-
-  with tarfile.open(grid_spec_tar, "w") as tar:
-    for ifile in tar_list: tar.add(ifile)
-
-  for ifile in tar_list:
-    Path(ifile).unlink()
+    make_yaml()
+    make_grid_spec()
+    make_mosaic()
+    make_grid()
+    make_data()
+
+    with tarfile.open(grid_spec_tar, "w") as tar:
+        for ifile in tar_list:
+            tar.add(ifile)
+
+    for ifile in tar_list:
+        Path(ifile).unlink()