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,7 @@
 import numpy as np
 import pandas as pd
 import xarray as xr
-from pyresample import kd_tree
+from ClimateGraph.utils.resample_engine import ResampleEngine, get_engine
 
 from ClimateGraph.reader import Reader
 from ClimateGraph.reader.reader.reader import ReadSpec
@@ -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,15 @@ 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(
-            src_geom,
-            dst_geom,
-            radius_of_influence=radius_of_influence,
-            neighbours=1,
+        info = resample_engine.prepare(
+            src_geom, dst_geom, radius_of_influence=radius_of_influence,
         )
+        _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 +460,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 +475,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

ClimateGraph/plot/plots.py

@@ -17,6 +17,7 @@
     TimeBucketEnum,
     TimestepEnum,
     manage_time_interval,
+    normalize_time,
 )
 
 from .plot import Plot
@@ -93,7 +94,7 @@ class TimeSeriesConfig(BasePlotConfig):
     base: str
     radius_of_influence: int | None = Field(default=None)
     other_data: str | list[str] | None = Field(default=None)
-    time_interval: str | list[str] | None = Field(default=None)
+    time: str | list[str] | None = Field(default=None)
     timestep: TimestepEnum | None = Field(default=None)
     reduction_method: ReductionMethodEnum = Field(default=ReductionMethodEnum.mean)
     colors: str | None = Field(default=None)  # TODO: implement
@@ -106,7 +107,12 @@ class Timeseries(Plot):
     aliases = ["ts", "time-series"]
 
     def plot(self):
-        """plot Timeseries plotting method.
+        """plot Iterate over self.plot_config.time entries, rendering once per entry."""
+        for time_interval in normalize_time(self.plot_config.time):
+            self._plot_one(time_interval)
+
+    def _plot_one(self, time_interval: str | None):
+        """_plot_one Timeseries plotting method for a single time entry.
         The process goes as follows:
         1) Process arguments.
         2) Process base data: Time resampling and aligning, and unit conversion.
@@ -131,7 +137,6 @@ def plot(self):
 
         radius_of_influence = self.plot_config.radius_of_influence
         timestep = self.plot_config.timestep
-        time_interval = self.plot_config.time_interval
 
         base = self.data[self.plot_config.base]
 
@@ -239,7 +244,7 @@ class ScatterConfig(BasePlotConfig):
     base: str
     other: str
     radius_of_influence: int
-    time_interval: str | None = Field(default=None)
+    time: str | list[str] | None = Field(default=None)
     dimension: str = Field(default="time")
     timestep: TimestepEnum | None = Field(default=None)
     reduction_method: ReductionMethodEnum = Field(default=ReductionMethodEnum.mean)
@@ -259,7 +264,12 @@ class Scatter(Plot):
     aliases = ["sc"]
 
     def plot(self):
-        """plot Scatter plotting method.
+        """plot Iterate over self.plot_config.time entries, rendering once per entry."""
+        for time_interval in normalize_time(self.plot_config.time):
+            self._plot_one(time_interval)
+
+    def _plot_one(self, time_interval: str | None):
+        """_plot_one Scatter plotting method for a single time entry.
         The process goes as follows:
         1) Process arguments.
         2) Process base data: Time resampling and aligning, and unit conversion.
@@ -277,7 +287,6 @@ def plot(self):
         vars = self.plot_config.vars
         radius_of_influence = self.plot_config.radius_of_influence
         timestep = self.plot_config.timestep
-        time_interval = self.plot_config.time_interval
         domains = {
             name: dom
             for name, dom in self.domains.items()
@@ -394,7 +403,7 @@ class SpatialOverlayConfig(BasePlotConfig):
     type: Literal["spatial-overlay", "spatialoverlay", "so"]
     base: str
     superposed: str
-    time_interval: str | None = Field(default=None)
+    time: str | list[str] | None = Field(default=None)
     levels: int = Field(default=10)
     reduction_method: ReductionMethodEnum = Field(default=ReductionMethodEnum.mean)
     crs: CRSEnum | None = Field(default=None)
@@ -413,7 +422,12 @@ class SpatialOverlay(Plot):
     config = SpatialOverlayConfig
 
     def plot(self):
-        """plot Spatial Overlay plotting method.
+        """plot Iterate over self.plot_config.time entries, rendering once per entry."""
+        for time_interval in normalize_time(self.plot_config.time):
+            self._plot_one(time_interval)
+
+    def _plot_one(self, time_interval: str | None):
+        """_plot_one Spatial Overlay plotting method for a single time entry.
         The process goes as follows:
         1) Process arguments.
         2) Iterate through Domains.
@@ -429,7 +443,6 @@ def plot(self):
         base: RegularGrid = self.data[self.plot_config.base]
         superposed: PointSurface = self.data[self.plot_config.superposed]
         vars = self.plot_config.vars
-        time_interval = self.plot_config.time_interval
         crs = (
             base.crs.crs if self.plot_config.crs is None else self.plot_config.crs.crs
         )  # TODO: make this simpler haha
@@ -574,7 +587,7 @@ class SpatialMapConfig(BasePlotConfig):
 
     type: Literal["spatial-map", "spatialmap", "map", "sm"]
     data: str
-    time_interval: str | None = Field(default=None)
+    time: str | list[str] | None = Field(default=None)
     levels: int = Field(default=10)
     reduction_method: ReductionMethodEnum = Field(default=ReductionMethodEnum.mean)
     crs: CRSEnum | None = Field(default=None)
@@ -601,7 +614,12 @@ class SpatialMap(Plot):
     config = SpatialMapConfig
 
     def plot(self):
-        """plot Spatial Map plotting method.
+        """plot Iterate over self.plot_config.time entries, rendering once per entry."""
+        for time_interval in normalize_time(self.plot_config.time):
+            self._plot_one(time_interval)
+
+    def _plot_one(self, time_interval: str | None):
+        """_plot_one Spatial Map plotting method for a single time entry.
         The process goes as follows:
         1) Process arguments.
         2) Iterate through Domains.
@@ -615,7 +633,6 @@ def plot(self):
         # Get relevant data from the config
         data: RegularGrid | PointSurface = self.data[self.plot_config.data]
         vars = self.plot_config.vars
-        time_interval = self.plot_config.time_interval
         crs = data.crs.crs if self.plot_config.crs is None else self.plot_config.crs.crs
         domains = {
             name: dom
@@ -735,7 +752,7 @@ class TimeCycleConfig(BasePlotConfig):
     base: str
     other_data: str | list[str] | None = Field(default=None)
     radius_of_influence: int | None = Field(default=None)
-    time_interval: str | list[str] | None = Field(default=None)
+    time: str | list[str] | None = Field(default=None)
     timestep: TimestepEnum | None = Field(default=None)
     time_buckets: TimeBucketEnum = Field(default=TimeBucketEnum.day)
     reduction_method: ReductionMethodEnum = Field(default=ReductionMethodEnum.mean)
@@ -771,6 +788,11 @@ class TimeCycle(Plot):
     aliases = ["time cycle", "cycle"]
 
     def plot(self):
+        """plot Iterate over self.plot_config.time entries, rendering once per entry."""
+        for time_interval in normalize_time(self.plot_config.time):
+            self._plot_one(time_interval)
+
+    def _plot_one(self, time_interval: str | None):
         # Get relevant data from the config
         vars = self.plot_config.vars
         domains = {
@@ -782,7 +804,6 @@ def plot(self):
             domains = {"": None}
 
         radius_of_influence = self.plot_config.radius_of_influence
-        time_interval = self.plot_config.time_interval
         timestep = self.plot_config.timestep
         time_bucket = (
             self.plot_config.time_buckets.value