Skip to content

Interfaces

This module defines the core interfaces, base classes, and validation framework for the statistical functions in the Monet Stats package.

Core interfaces and base classes for the Monet Stats package (Aero Protocol Compliant).

This module defines the core interfaces, base classes, and validation framework for the statistical functions in the Monet Stats package.

BaseStatisticalMetric

Bases: StatisticalMetric

Base implementation for statistical metrics with common functionality.

Source code in src/monet_stats/interfaces.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
class BaseStatisticalMetric(StatisticalMetric):
    """
    Base implementation for statistical metrics with common functionality.
    """

    def __init__(self) -> None:
        self.name = self.__class__.__name__
        self.description = self.__doc__ or "Statistical metric"

    def validate_inputs(
        self,
        obs: Union[np.ndarray, xr.DataArray],
        mod: Union[np.ndarray, xr.DataArray],
        **kwargs: Any,
    ) -> bool:
        """
        Validate input parameters for the metric (Aero Protocol: Lazy-friendly).

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.
        **kwargs : Any
            Additional parameters specific to the metric.

        Returns
        -------
        bool
            True if inputs are valid.

        Raises
        ------
        TypeError
            If inputs are not numpy arrays or xarray DataArrays.
        ValueError
            If shapes mismatch or no finite values are present.
        """
        # Check if inputs are arrays or xarray DataArrays
        if not (isinstance(obs, (np.ndarray, xr.DataArray)) and isinstance(mod, (np.ndarray, xr.DataArray))):
            raise TypeError("obs and mod must be numpy arrays or xarray DataArrays")

        # Check if shapes match (lazy-safe as shape is metadata)
        if hasattr(obs, "shape") and hasattr(mod, "shape"):
            if obs.shape != mod.shape:
                try:
                    np.broadcast_shapes(obs.shape, mod.shape)
                except ValueError:
                    raise ValueError(f"obs and mod must have compatible shapes, got {obs.shape} and {mod.shape}")

        # Note: We avoid .values here to maintain laziness.
        # Deep data validation (like checking for NaNs) is deferred to the computation phase
        # to avoid premature Dask triggers.
        return True

    def _handle_xarray(
        self,
        obs: xr.DataArray,
        mod: xr.DataArray,
        func: Callable,
        axis: Optional[Union[int, str, Iterable[Union[int, str]]]] = None,
        **kwargs: Any,
    ) -> xr.DataArray:
        """
        Handle xarray DataArray inputs by aligning and applying function.

        Parameters
        ----------
        obs : xarray.DataArray
            Observed values.
        mod : xarray.DataArray
            Model/predicted values.
        func : callable
            Function to apply to the data.
        axis : int, str, or iterable, optional
            Axis or dimension along which to compute.
        **kwargs : Any
            Additional parameters for the function.

        Returns
        -------
        xarray.DataArray
            Result of applying the function with history updated.
        """
        from .data_processing import align_arrays

        obs, mod = align_arrays(obs, mod)

        if axis is not None:
            # Handle axis parameter for xarray
            if isinstance(axis, int):
                dim = obs.dims[axis]
            else:
                dim = axis
            res = func(obs, mod, dim=dim, **kwargs)
        else:
            res = func(obs, mod, **kwargs)

        # Ensure attributes from obs are preserved in the result for provenance
        if hasattr(res, "attrs"):
            for k, v in obs.attrs.items():
                if k not in res.attrs:
                    res.attrs[k] = v

        return _update_history(res, self.name)

    def _handle_numpy(
        self,
        obs: np.ndarray,
        mod: np.ndarray,
        func: Callable,
        axis: Optional[Union[int, Iterable[int]]] = None,
        **kwargs: Any,
    ) -> Union[np.ndarray, float]:
        """
        Handle numpy array inputs by applying function.

        Parameters
        ----------
        obs : numpy.ndarray
            Observed values.
        mod : numpy.ndarray
            Model/predicted values.
        func : callable
            Function to apply to the data.
        axis : int or iterable of int, optional
            Axis along which to compute.
        **kwargs : Any
            Additional parameters for the function.

        Returns
        -------
        numpy.ndarray or float
            Result of applying the function.
        """
        return func(obs, mod, axis=axis, **kwargs)

    def _handle_masked_arrays(
        self,
        obs: np.ndarray,
        mod: np.ndarray,
        func: Callable,
        axis: Optional[Union[int, Iterable[int]]] = None,
        **kwargs: Any,
    ) -> Union[np.ndarray, float]:
        """
        Handle masked array inputs by applying function.

        Parameters
        ----------
        obs : numpy.ndarray
            Observed values.
        mod : numpy.ndarray
            Model/predicted values.
        func : callable
            Function to apply to the data.
        axis : int or iterable of int, optional
            Axis along which to compute.
        **kwargs : Any
            Additional parameters for the function.

        Returns
        -------
        numpy.ndarray or float
            Result of applying the function.
        """
        obs_ma = np.ma.masked_invalid(obs)
        mod_ma = np.ma.masked_invalid(mod)
        return func(obs_ma, mod_ma, axis=axis, **kwargs)

validate_inputs(obs, mod, **kwargs)

Validate input parameters for the metric (Aero Protocol: Lazy-friendly).

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values. **kwargs : Any Additional parameters specific to the metric.

Returns

bool True if inputs are valid.

Raises

TypeError If inputs are not numpy arrays or xarray DataArrays. ValueError If shapes mismatch or no finite values are present.

Source code in src/monet_stats/interfaces.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
def validate_inputs(
    self,
    obs: Union[np.ndarray, xr.DataArray],
    mod: Union[np.ndarray, xr.DataArray],
    **kwargs: Any,
) -> bool:
    """
    Validate input parameters for the metric (Aero Protocol: Lazy-friendly).

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.
    **kwargs : Any
        Additional parameters specific to the metric.

    Returns
    -------
    bool
        True if inputs are valid.

    Raises
    ------
    TypeError
        If inputs are not numpy arrays or xarray DataArrays.
    ValueError
        If shapes mismatch or no finite values are present.
    """
    # Check if inputs are arrays or xarray DataArrays
    if not (isinstance(obs, (np.ndarray, xr.DataArray)) and isinstance(mod, (np.ndarray, xr.DataArray))):
        raise TypeError("obs and mod must be numpy arrays or xarray DataArrays")

    # Check if shapes match (lazy-safe as shape is metadata)
    if hasattr(obs, "shape") and hasattr(mod, "shape"):
        if obs.shape != mod.shape:
            try:
                np.broadcast_shapes(obs.shape, mod.shape)
            except ValueError:
                raise ValueError(f"obs and mod must have compatible shapes, got {obs.shape} and {mod.shape}")

    # Note: We avoid .values here to maintain laziness.
    # Deep data validation (like checking for NaNs) is deferred to the computation phase
    # to avoid premature Dask triggers.
    return True

DataProcessor

Data processing utilities (Legacy wrapper for data_processing module).

Source code in src/monet_stats/interfaces.py 
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
class DataProcessor:
    """
    Data processing utilities (Legacy wrapper for data_processing module).
    """

    @staticmethod
    def to_numpy(data: Any) -> np.ndarray:
        """
        Convert data to numpy array (Triggers compute).

        Parameters
        ----------
        data : Any
            Input data.

        Returns
        -------
        numpy.ndarray
            Converted numpy array.
        """
        from .data_processing import to_numpy

        return to_numpy(data)

    @staticmethod
    def align_arrays(
        obs: Union[np.ndarray, xr.DataArray], mod: Union[np.ndarray, xr.DataArray]
    ) -> Tuple[Union[np.ndarray, xr.DataArray], Union[np.ndarray, xr.DataArray]]:
        """
        Align two arrays for comparison.

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.

        Returns
        -------
        tuple
            Aligned obs and mod arrays.
        """
        from .data_processing import align_arrays

        return align_arrays(obs, mod)

    @staticmethod
    def handle_missing_values(
        obs: Union[np.ndarray, xr.DataArray], mod: Union[np.ndarray, xr.DataArray], strategy: str = "pairwise"
    ) -> Tuple[Union[np.ndarray, xr.DataArray], Union[np.ndarray, xr.DataArray]]:
        """
        Handle missing values in arrays.

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.
        strategy : str, optional
            Strategy for handling missing values ('pairwise', 'listwise').

        Returns
        -------
        tuple
            Arrays with missing values handled according to strategy.
        """
        from .data_processing import handle_missing_values

        return handle_missing_values(obs, mod, strategy=strategy)

align_arrays(obs, mod) staticmethod

Align two arrays for comparison.

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values.

Returns

tuple Aligned obs and mod arrays.

Source code in src/monet_stats/interfaces.py 
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
@staticmethod
def align_arrays(
    obs: Union[np.ndarray, xr.DataArray], mod: Union[np.ndarray, xr.DataArray]
) -> Tuple[Union[np.ndarray, xr.DataArray], Union[np.ndarray, xr.DataArray]]:
    """
    Align two arrays for comparison.

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.

    Returns
    -------
    tuple
        Aligned obs and mod arrays.
    """
    from .data_processing import align_arrays

    return align_arrays(obs, mod)

handle_missing_values(obs, mod, strategy='pairwise') staticmethod

Handle missing values in arrays.

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values. strategy : str, optional Strategy for handling missing values ('pairwise', 'listwise').

Returns

tuple Arrays with missing values handled according to strategy.

Source code in src/monet_stats/interfaces.py 
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
@staticmethod
def handle_missing_values(
    obs: Union[np.ndarray, xr.DataArray], mod: Union[np.ndarray, xr.DataArray], strategy: str = "pairwise"
) -> Tuple[Union[np.ndarray, xr.DataArray], Union[np.ndarray, xr.DataArray]]:
    """
    Handle missing values in arrays.

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.
    strategy : str, optional
        Strategy for handling missing values ('pairwise', 'listwise').

    Returns
    -------
    tuple
        Arrays with missing values handled according to strategy.
    """
    from .data_processing import handle_missing_values

    return handle_missing_values(obs, mod, strategy=strategy)

to_numpy(data) staticmethod

Convert data to numpy array (Triggers compute).

Parameters

data : Any Input data.

Returns

numpy.ndarray Converted numpy array.

Source code in src/monet_stats/interfaces.py 
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
@staticmethod
def to_numpy(data: Any) -> np.ndarray:
    """
    Convert data to numpy array (Triggers compute).

    Parameters
    ----------
    data : Any
        Input data.

    Returns
    -------
    numpy.ndarray
        Converted numpy array.
    """
    from .data_processing import to_numpy

    return to_numpy(data)

PerformanceOptimizer

Performance optimization utilities (Legacy wrapper for performance module).

Source code in src/monet_stats/interfaces.py 
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
class PerformanceOptimizer:
    """
    Performance optimization utilities (Legacy wrapper for performance module).
    """

    @staticmethod
    def chunk_array(arr: np.ndarray, chunk_size: int = 1000000) -> list:
        """
        Split array into chunks for memory-efficient processing.

        Parameters
        ----------
        arr : numpy.ndarray
            Input array to chunk.
        chunk_size : int, optional
            Size of each chunk (number of elements).

        Returns
        -------
        list
            List of array chunks.
        """
        from .performance import chunk_array

        return chunk_array(arr, chunk_size=chunk_size)

    @staticmethod
    def vectorize_function(func: Callable, *args: Any, **kwargs: Any) -> Any:
        """
        Apply function in a vectorized manner.

        Parameters
        ----------
        func : callable
            Function to vectorize.
        *args : Any
            Arguments to pass to function.
        **kwargs : Any
            Keyword arguments to pass to function.

        Returns
        -------
        Any
            Result of vectorized function application.
        """
        from .performance import vectorize_function

        return vectorize_function(func, *args, **kwargs)

chunk_array(arr, chunk_size=1000000) staticmethod

Split array into chunks for memory-efficient processing.

Parameters

arr : numpy.ndarray Input array to chunk. chunk_size : int, optional Size of each chunk (number of elements).

Returns

list List of array chunks.

Source code in src/monet_stats/interfaces.py 
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
@staticmethod
def chunk_array(arr: np.ndarray, chunk_size: int = 1000000) -> list:
    """
    Split array into chunks for memory-efficient processing.

    Parameters
    ----------
    arr : numpy.ndarray
        Input array to chunk.
    chunk_size : int, optional
        Size of each chunk (number of elements).

    Returns
    -------
    list
        List of array chunks.
    """
    from .performance import chunk_array

    return chunk_array(arr, chunk_size=chunk_size)

vectorize_function(func, *args, **kwargs) staticmethod

Apply function in a vectorized manner.

Parameters

func : callable Function to vectorize. args : Any Arguments to pass to function. *kwargs : Any Keyword arguments to pass to function.

Returns

Any Result of vectorized function application.

Source code in src/monet_stats/interfaces.py 
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
@staticmethod
def vectorize_function(func: Callable, *args: Any, **kwargs: Any) -> Any:
    """
    Apply function in a vectorized manner.

    Parameters
    ----------
    func : callable
        Function to vectorize.
    *args : Any
        Arguments to pass to function.
    **kwargs : Any
        Keyword arguments to pass to function.

    Returns
    -------
    Any
        Result of vectorized function application.
    """
    from .performance import vectorize_function

    return vectorize_function(func, *args, **kwargs)

PluginInterface

Bases: ABC

Interface for creating custom statistical metrics as plugins.

Source code in src/monet_stats/interfaces.py 
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
class PluginInterface(ABC):
    """
    Interface for creating custom statistical metrics as plugins.
    """

    @abstractmethod
    def name(self) -> str:
        """
        Return the name of the metric.

        Returns
        -------
        str
            Metric name.
        """

    @abstractmethod
    def compute(
        self,
        obs: Union[np.ndarray, xr.DataArray],
        mod: Union[np.ndarray, xr.DataArray],
        **kwargs: Any,
    ) -> Union[float, np.ndarray, xr.DataArray]:
        """
        Compute the custom metric.

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.
        **kwargs : Any
            Additional parameters.

        Returns
        -------
        float or numpy.ndarray or xarray.DataArray
            Computed metric value(s).
        """

    @abstractmethod
    def description(self) -> str:
        """
        Return the description of the metric.

        Returns
        -------
        str
            Metric description.
        """

    @abstractmethod
    def validate_inputs(
        self,
        obs: Union[np.ndarray, xr.DataArray],
        mod: Union[np.ndarray, xr.DataArray],
        **kwargs: Any,
    ) -> bool:
        """
        Validate inputs for the metric.

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.
        **kwargs : Any
            Additional parameters.

        Returns
        -------
        bool
            True if inputs are valid, False otherwise.
        """

compute(obs, mod, **kwargs) abstractmethod

Compute the custom metric.

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values. **kwargs : Any Additional parameters.

Returns

float or numpy.ndarray or xarray.DataArray Computed metric value(s).

Source code in src/monet_stats/interfaces.py 
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
@abstractmethod
def compute(
    self,
    obs: Union[np.ndarray, xr.DataArray],
    mod: Union[np.ndarray, xr.DataArray],
    **kwargs: Any,
) -> Union[float, np.ndarray, xr.DataArray]:
    """
    Compute the custom metric.

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.
    **kwargs : Any
        Additional parameters.

    Returns
    -------
    float or numpy.ndarray or xarray.DataArray
        Computed metric value(s).
    """

description() abstractmethod

Return the description of the metric.

Returns

str Metric description.

Source code in src/monet_stats/interfaces.py 
413
414
415
416
417
418
419
420
421
422
@abstractmethod
def description(self) -> str:
    """
    Return the description of the metric.

    Returns
    -------
    str
        Metric description.
    """

name() abstractmethod

Return the name of the metric.

Returns

str Metric name.

Source code in src/monet_stats/interfaces.py 
377
378
379
380
381
382
383
384
385
386
@abstractmethod
def name(self) -> str:
    """
    Return the name of the metric.

    Returns
    -------
    str
        Metric name.
    """

validate_inputs(obs, mod, **kwargs) abstractmethod

Validate inputs for the metric.

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values. **kwargs : Any Additional parameters.

Returns

bool True if inputs are valid, False otherwise.

Source code in src/monet_stats/interfaces.py 
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
@abstractmethod
def validate_inputs(
    self,
    obs: Union[np.ndarray, xr.DataArray],
    mod: Union[np.ndarray, xr.DataArray],
    **kwargs: Any,
) -> bool:
    """
    Validate inputs for the metric.

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.
    **kwargs : Any
        Additional parameters.

    Returns
    -------
    bool
        True if inputs are valid, False otherwise.
    """

StatisticalMetric

Bases: ABC

Abstract base class for all statistical metrics.

This class defines the common interface for all statistical metrics in the Monet Stats package, ensuring consistency across different types of metrics (error, correlation, efficiency, etc.).

Source code in src/monet_stats/interfaces.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
class StatisticalMetric(ABC):
    """
    Abstract base class for all statistical metrics.

    This class defines the common interface for all statistical metrics
    in the Monet Stats package, ensuring consistency across different
    types of metrics (error, correlation, efficiency, etc.).
    """

    @abstractmethod
    def compute(
        self,
        obs: Union[np.ndarray, xr.DataArray],
        mod: Union[np.ndarray, xr.DataArray],
        **kwargs: Any,
    ) -> Union[float, np.ndarray, xr.DataArray]:
        """
        Compute the statistical metric.

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.
        **kwargs : Any
            Additional parameters specific to the metric.

        Returns
        -------
        float or numpy.ndarray or xarray.DataArray
            The computed metric value(s).
        """

    @abstractmethod
    def validate_inputs(
        self,
        obs: Union[np.ndarray, xr.DataArray],
        mod: Union[np.ndarray, xr.DataArray],
        **kwargs: Any,
    ) -> bool:
        """
        Validate input parameters for the metric.

        Parameters
        ----------
        obs : numpy.ndarray or xarray.DataArray
            Observed values.
        mod : numpy.ndarray or xarray.DataArray
            Model/predicted values.
        **kwargs : Any
            Additional parameters specific to the metric.

        Returns
        -------
        bool
            True if inputs are valid, False otherwise.
        """

compute(obs, mod, **kwargs) abstractmethod

Compute the statistical metric.

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values. **kwargs : Any Additional parameters specific to the metric.

Returns

float or numpy.ndarray or xarray.DataArray The computed metric value(s).

Source code in src/monet_stats/interfaces.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@abstractmethod
def compute(
    self,
    obs: Union[np.ndarray, xr.DataArray],
    mod: Union[np.ndarray, xr.DataArray],
    **kwargs: Any,
) -> Union[float, np.ndarray, xr.DataArray]:
    """
    Compute the statistical metric.

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.
    **kwargs : Any
        Additional parameters specific to the metric.

    Returns
    -------
    float or numpy.ndarray or xarray.DataArray
        The computed metric value(s).
    """

validate_inputs(obs, mod, **kwargs) abstractmethod

Validate input parameters for the metric.

Parameters

obs : numpy.ndarray or xarray.DataArray Observed values. mod : numpy.ndarray or xarray.DataArray Model/predicted values. **kwargs : Any Additional parameters specific to the metric.

Returns

bool True if inputs are valid, False otherwise.

Source code in src/monet_stats/interfaces.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@abstractmethod
def validate_inputs(
    self,
    obs: Union[np.ndarray, xr.DataArray],
    mod: Union[np.ndarray, xr.DataArray],
    **kwargs: Any,
) -> bool:
    """
    Validate input parameters for the metric.

    Parameters
    ----------
    obs : numpy.ndarray or xarray.DataArray
        Observed values.
    mod : numpy.ndarray or xarray.DataArray
        Model/predicted values.
    **kwargs : Any
        Additional parameters specific to the metric.

    Returns
    -------
    bool
        True if inputs are valid, False otherwise.
    """