Better input validations

[Gorkowski]

Is there a better way to validate inputs for functions. So we don't duplicate.
GPT thinks, decorators or helper functions (example below). I just want the error to raise correctly so you know which function/variable is the problem.

thoughts @mahf708 ?

To avoid duplicating validation logic across multiple functions, you can use helper functions or decorators for reusable input validation. This modular approach reduces repetition and improves maintainability. Here's an improved structure for your use case:

1. Helper Functions

Define utility functions to handle input validation. This centralizes the validation logic and keeps your main function clean.

import numpy as np

def validate_positive(value, name):
    """
    Validates that the input value is positive.
    
    Arguments:
        value: The value to validate. Can be a scalar or ndarray.
        name: The name of the parameter for error messages.
        
    Raises:
        ValueError: If the value is not positive.
    """
    if np.any(value <= 0):
        raise ValueError(f"{name} must be positive")

def validate_inputs(**kwargs):
    """
    Validates multiple inputs for positivity.
    
    Arguments:
        kwargs: A dictionary of parameter names and their corresponding values.
    """
    for name, value in kwargs.items():
        validate_positive(value, name)

def calculate_partial_pressure(
    concentration: Union[float, np.ndarray],
    molar_mass: Union[float, np.ndarray],
    temperature: Union[float, np.ndarray],
) -> Union[float, np.ndarray]:
    """
    Calculate the partial pressure of a gas from its concentration, molar mass,
    and temperature.

    Parameters:
        concentration: Concentration of the gas in kg/m^3.
        molar_mass: Molar mass of the gas in kg/mol.
        temperature: Temperature in Kelvin.

    Returns:
        Partial pressure of the gas in Pascals (Pa).
    """
    # Input validation
    validate_inputs(
        concentration=concentration,
        molar_mass=molar_mass,
        temperature=temperature,
    )

    # Calculate the partial pressure
    return (concentration * float(GAS_CONSTANT.m) * temperature) / molar_mass

2. Using Decorators

Decorators allow you to apply validation to multiple functions without modifying their code. Here's an example:

from functools import wraps
import numpy as np

def validate_args_positive(arg_names):
    """
    A decorator to validate that specified arguments are positive.

    Arguments:
        arg_names: List of argument names to validate.

    Returns:
        A decorator for input validation.
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Map argument names to values
            arg_dict = func.__annotations__
            for name in arg_names:
                value = kwargs.get(name, args[list(arg_dict).index(name)])
                validate_positive(value, name)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_args_positive(["concentration", "molar_mass", "temperature"])
def calculate_partial_pressure(
    concentration: Union[float, np.ndarray],
    molar_mass: Union[float, np.ndarray],
    temperature: Union[float, np.ndarray],
) -> Union[float, np.ndarray]:
    """
    Calculate the partial pressure of a gas from its concentration, molar mass,
    and temperature.

    Parameters:
        concentration: Concentration of the gas in kg/m^3.
        molar_mass: Molar mass of the gas in kg/mol.
        temperature: Temperature in Kelvin.

    Returns:
        Partial pressure of the gas in Pascals (Pa).
    """
    return (concentration * float(GAS_CONSTANT.m) * temperature) / molar_mass

[mahf708]

I like both solutions

In general, I am fine(ish) with code duplication in testing and stuff like confirmation/error-handling. But maybe it is getting out of hand with bots telling us to do so much of it?

[Gorkowski]

Yeah, in the tests I was fine with.

I was more feeling that the input to the functions started to feel a bit off with the multiple if statement checks.

I like the decorators better, as you can stack them for different variables and the runtime error is clear enough.

Traceback (most recent call last):
  File "example.py", line 47, in <module>
    calculate_partial_pressure(concentration=-1.0, molar_mass=0.028, temperature=300.0)
  File "example.py", line 24, in wrapper
    validate_positive(value, name)
  File "example.py", line 9, in validate_positive
    raise ValueError(f"{name} must be positive.")
ValueError: concentration must be positive.

[mahf708]

Okay, then let's have a particula-wide decorator? @particula.validate_inputs(...)

What cases do we need to cover?

• positive
• negative
• nonpositive
• nonnegative
• nonzero
• ...

Then, we can have validate_inputs take a dict ... e.g.,

from functools import wraps
import numpy as np

def validate_inputs(dict_args):
    """
    A decorator to validate that specified arguments are positive.

    Arguments:
        arg_names: List of argument names to validate.

    Returns:
        A decorator for input validation.
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Map argument names to values
            arg_dict = func.__annotations__
            for name, comp in dict_args.items():
                value = kwargs.get(name, args[list(arg_dict).index(name)])
                if comp == "positive":
                    validate_positive(value, name)
                elif comp == "negative":
                    ...
            return func(*args, **kwargs)
        return wrapper
    return decorator

then have decorate functions with like @particula.validate_inputs({"concentration": "positive", ...})

[mahf708]

Btw, do you know if we can use multiple decorators?

[Gorkowski]

I think so, and GPT says yes 😂