Centralized the logging level and made it settable via CLI and config file. Moved the resample logic into a resampling engine, added a convenience for_each domain expansion, changed time_interval to just TIME and made generally possible to define multiple time domains there as a list, removed time iteration to plot and added a _plot_one func, eventually this plot func will abstract iteration and move up to Plot class

Author: AntonioTorga

ClimateGraph/appkernel.py

@@ -4,8 +4,6 @@
 
 from ClimateGraph.utils.parser import Parser
 
-logging.basicConfig(level=logging.INFO)
-
 
 class AppKernel:
     """ClimateGraph execution and state manager. Orquestrates the other modules."""
@@ -65,19 +63,34 @@ def set_analysis_data(self, analysis: dict | None = None):
         self.output_path = analysis.get("output_path", Path("./"))
         self.workers = analysis.get("workers")
 
-    def run(self, control_path: Path):
+    def _configure_logging(self):
+        """_configure_logging Set the root logger level from self.debug.
+
+        The only place in the codebase that calls ``logging.basicConfig``.
+        ``force=True`` so this always wins regardless of import order, even if
+        some other library configured logging before this runs.
+        """
+        level = logging.DEBUG if self.debug else logging.INFO
+        logging.basicConfig(level=level, force=True)
+
+    def run(self, control_path: Path, debug_override: bool = False):
         """run Run the ClimateGraph routine.
 
         Parameters
         ----------
         control_path : Path
             Path of the configuration file for the ClimateGraph run.
+        debug_override : bool, optional
+            CLI override for the control file's ``debug`` setting. ORed with
+            the control file's value, so passing True always wins. By default False
         """
         self.analysis, self.data, self.plots, self.domains = self.read_control(
             control_path
         )
 
         self.set_analysis_data()
+        self.debug = debug_override or self.debug
+        self._configure_logging()
         # if self.eager : self.load_data()
         with self._dask_client():
             self.plot()

ClimateGraph/cli.py

@@ -24,16 +24,26 @@ def run(
             help="File defining the analysis.",
         ),
     ],
+    debug: Annotated[
+        bool,
+        typer.Option(
+            "--debug",
+            help="Force DEBUG-level logging. ORed with the control file's debug setting.",
+        ),
+    ] = False,
 ):
-    """run Run the ClimateGraph routine with a control file.
+    """Run the ClimateGraph routine with a control file.
 
     Parameters
     ----------
     control_file : Annotated[ Path, typer.Argument, optional
         Path of the configuration file for the ClimateGraph run, by default True, dir_okay=False, file_okay=True, resolve_path=True, help="File defining the analysis.", ), ]
+    debug : Annotated[bool, typer.Option, optional
+        When passed, forces DEBUG-level logging regardless of the control file's
+        debug setting. By default False
     """
     appK = AppKernel()
-    appK.run(control_file)
+    appK.run(control_file, debug_override=debug)
 
 
 @app.command()

ClimateGraph/data/data.py

@@ -6,7 +6,6 @@
 import numpy as np
 import pandas as pd
 import xarray as xr
-from pyresample import kd_tree
 
 from ClimateGraph.reader import Reader
 from ClimateGraph.reader.reader.reader import ReadSpec
@@ -19,6 +18,7 @@
 )
 from ClimateGraph.utils.general_utils import ReductionMethodEnum
 from ClimateGraph.utils.registry import RegistryMixin
+from ClimateGraph.utils.resample_engine import ResampleEngine, get_engine
 
 
 class Data(RegistryMixin, ABC):
@@ -398,7 +398,6 @@ def get_coordinates(
             coords = coords[0]
         return coords
 
-    # Might need to become a whole pairing engine in some time. But for now this will do
     def resample_vars(
         self,
         other: "Data",
@@ -407,8 +406,10 @@ def resample_vars(
         time_interval: str | None = None,
         radius_of_influence: int = 10000,
         time_tolerance: str | None = "30min",
+        engine: str | ResampleEngine = "pyresample",
+        engine_kwargs: dict | None = None,
     ) -> xr.DataArray | xr.Dataset:
-        """resample_vars Resample the requested vars using Pyresample and the geom attributes. Until now only NearestNeighbour method is being used.
+        """Resample the requested vars using the specified ResampleEngine.
 
         Parameters
         ----------
@@ -421,9 +422,15 @@ def resample_vars(
         time_interval : str | None, optional
             Time interval in dd/mm/yyyy-dd/mm/yyyy or d/m/yyyy-d/m/yyyy, by default None
         radius_of_influence : int, optional
-            Radius length in meters to use for resampling with nearest neighbours. Lower improves computation time but may result in less resulting data, by default 10000
+            Radius length in meters to use for resampling. by default 10000
         time_tolerance : str | None, optional
-            Pandas-style timedelta used as the tolerance when snapping ``other``'s time axis onto ``self``'s via nearest-neighbour reindex. Handles cases where the two sources are on the same cadence but offset (e.g. CHIMERE at HH:30 vs. point-surface at HH:00). Set to ``None`` to disable snapping. Default ``"30min"``.
+            Pandas-style timedelta used as the tolerance when snapping ``other``'s
+            time axis onto ``self``'s via nearest-neighbour reindex. Default ``"30min"``.
+        engine : str | ResampleEngine, optional
+            Resample backend name or instance. Default ``"pyresample"``.
+        engine_kwargs : dict | None, optional
+            Extra kwargs forwarded to the engine constructor
+            (e.g. ``method``, ``sigmas``). Default None.
 
         Returns
         -------
@@ -433,20 +440,17 @@ def resample_vars(
         if isinstance(vars, str):
             vars = [vars]
 
+        resample_engine = get_engine(engine, **(engine_kwargs or {}))
         src_geom = other.geom
         dst_geom = self.geom
 
-        valid_input, valid_output, index_array, dist_array = kd_tree.get_neighbour_info(
+        info = resample_engine.prepare(
             src_geom,
             dst_geom,
             radius_of_influence=radius_of_influence,
-            neighbours=1,
         )
+        _resample = resample_engine.make_resampler(info, dst_geom.shape)
 
-        # Establish the destination time grid up front so var_src can be snapped onto
-        # it before resampling. Without this, sources whose time axis is offset from
-        # self's (e.g. CHIMERE labelled at HH:30 vs point-surface at HH:00) end up
-        # producing a resampled array whose time length doesn't match self's.
         if self.resampled is None:
             self.resampled = self.obj.drop_vars(list(self.obj.data_vars))
             self.resampled = time_resampling(
@@ -458,14 +462,10 @@ def resample_vars(
             var_dst_dims = self.get_var(var).sizes
             var_src = other.get_var(var)
 
-            # The caller wants the var either in a specified unit (dict form) or
-            # in the unit of the resampling base (list/str form). var_unit yields
-            # None when units weren't declared, and change_unit no-ops on None.
             dst_unit = self.var_unit(var) if isinstance(vars, list | str) else vars[var]
             src_unit = other.var_unit(var)
             var_src = change_unit(var_src, src_unit, dst_unit)
 
-            # time resampling
             var_src = time_resampling(
                 var_src, timestep=timestep, time_interval=time_interval
             )
@@ -477,22 +477,6 @@ def resample_vars(
                     tolerance=pd.Timedelta(time_tolerance),
                 )
 
-            def _resample(x):
-                return kd_tree.get_sample_from_neighbour_info(
-                    "nn",
-                    dst_geom.shape,
-                    x,
-                    valid_input,
-                    valid_output,
-                    index_array,
-                    dist_array,
-                    fill_value=np.nan,
-                )
-
-            # input_core_dims: only the geom_dims of the source (the horizontal dims
-            # the pyresample geometry was built from). Any extra dims like z are left
-            # out so apply_ufunc loops over them automatically, broadcasting the
-            # horizontal resampling across each vertical level independently.
             src_geom_dims = [d for d in var_src.dims if d in set(other.geom_dims)]
             dst_geom_dims = [d for d in var_dst_dims if d in set(self.geom_dims)]
             resampled = xr.apply_ufunc(

ClimateGraph/domain/domain.py

@@ -1,13 +1,10 @@
-import logging
 from abc import ABC, abstractmethod
 
 import xarray as xr
 from pydantic import BaseModel
 
 from ClimateGraph.utils.registry import RegistryMixin
 
-logging.basicConfig(level=logging.INFO)  # TODO: make this settable from yaml file.
-
 # TODO: Change the use of BaseModel for actual attributes to improve modularization.
 
 

ClimateGraph/domain/domains.py

@@ -16,6 +16,10 @@ class AttributeConfig(BaseModel):
     type: Literal["attribute", "attr"]
     field_name: str
     field_value: Any
+    one_for_each: bool = False
+    """When field_value is a list and this is True, the parser expands this
+    single domain block into one Attribute domain per value. When False (default),
+    the set is analyzed together."""
 
 
 class Attribute(Domain):
@@ -39,7 +43,11 @@ def apply(self, data: xr.Dataset | xr.DataArray):
         """
         field_name = self.domain_config.field_name
         field_value = self.domain_config.field_value
-        return data.where((data[field_name] == field_value).compute(), drop=True)
+        if isinstance(field_value, list):
+            mask = data[field_name].isin(field_value)
+        else:
+            mask = data[field_name] == field_value
+        return data.where(mask.compute(), drop=True)
 
 
 class PolygonConfig(BaseModel):

ClimateGraph/plot/plot.py

@@ -1,4 +1,3 @@
-import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
 
@@ -12,8 +11,6 @@
 from ClimateGraph.domain import Domain
 from ClimateGraph.utils.registry import RegistryMixin
 
-logging.basicConfig(level=logging.INFO)  # TODO: make this settable from yaml file.
-
 # Which keys in plot_kwargs get routed to which matplotlib call. A given key
 # may legitimately belong to more than one sink (e.g. `dpi` applies to both
 # the figure and savefig), so the sets overlap on purpose. matplotlib rejects