Add type hinting

[ggalloni]

This is the first attempt to add type hinting throughout the repo, mentioned in #189.

I was quite generic on many occasions as this is just supposed to give us a place to work on this and can be refined once we agree on some strategy.

[cmbant]

The most useful place to have type hints is annotations for variables that are only defined in the yaml (so consistency can then be checked just using standard editors like vs code/Pycharm). In many places types can be inferred accurately, and little to be gained by adding them explicitly unless useful for doc of public interface.

Note: want to make sure you don't statically import anything that's an optional dependence (e.g. ccl).

[ggalloni]

I added checks for the quantities from yaml files, which now must match the expected types. Let me know what you think of the current strategy.

For the explicit typing in the code, I am a fan of a bit of redundancy in this case, but it is just a matter of taste. I think it makes the code more readable as the user knows, at first sight, what type a certain quantity is. Still, I am planning to go through the modifications and clean the code, because some may be too obvious.

[cmbant]

There's a CobayaComponent-level method intended for parameter validation, validate_info (https://github.com/CobayaSampler/cobaya/blob/master/cobaya/component.py#L415). You could override this in one of SOLikeT's base classes to check that all assignments match the types in the annotations. (It shouldn't really be necessary to repeat the type once defined in the attribute's annotation).

But perhaps better would be to add a general "_enforces_types" class attribute to Cobaya, and add code to Cobaya's Component.validate_info to fully validate types for any descendant class that sets _enforce_types is True.
I'm not sure if there's a built-in python function to validate a variable against a type, but Sonnet suggests using typeguard (from typeguard import check_type) or something like this

def validate_attribute(cls, name, value):
    hints = get_type_hints(cls)
    if name in hints:
        expected_type = hints[name]
        if hasattr(expected_type, '__origin__'):
            if expected_type.__origin__ is Union:
                if not any(isinstance(value, t) for t in expected_type.__args__):
                    raise TypeError(f"Attribute '{name}' must be one of types {expected_type.__args__}, not {type(value)}")
            elif expected_type.__origin__ is Optional:
                if value is not None and not isinstance(value, expected_type.__args__[0]):
                    raise TypeError(f"Attribute '{name}' must be of type {expected_type.__args__[0]} or None, not {type(value)}")
        elif not isinstance(value, expected_type):
            raise TypeError(f"Attribute '{name}' must be of type {expected_type}, not {type(value)}")

[Note I am travelling most of the next two weeks, so likely not responding to any Cobaya issues]

[ggalloni]

Starting from the code you suggested, I refactored the type-checking functions to avoid repeating the types. Also, now they accept essentially all types, including nested ones (e.g. List[str], Dict[str, float], Tuple[str, str, int], etc).

As a testing ground, I used the Bias class. Still, eventually, something similar can be moved within Cobaya and substitute validate_info (the method _validate_attribute in Bias is essentially equivalent, but allows for all types).