Could the Quantity object be defined as a pydantic model or at least have the possibility of being serialized or deserialized as such?

[rmanno91]

I think it would be valuable to define the Quantity class as a pydantic model:

• no need to perform the validation of input parameters
• simplifies the development of API in sight of the current developments in the direction of WebApp
• serialize and desirialize the model via json

The shortcut to that would be to define a __get_pydantic_core_schema__ method directly within the Quantity.
I did a proof of concept wrapping the Quantity object into a wrapper:

class QuantityWrapper(Quantity):
    """A wrapper for Quantity that allows for pydantic representation."""

    def __init__(self, value: list[float], units: str, **kwargs):
        """Initialize the QuantityWrapper."""
        super().__init__(value=value, units=units)
        self.extra_fields = kwargs

    @classmethod
    def __get_pydantic_core_schema__(cls, source_type, handler):
        """Define the pydantic core schema for QuantityWrapper."""

        def validate_quantity_type(obj):
            if isinstance(obj, cls):
                return obj
            if isinstance(obj, Quantity):
                return cls(value=obj.value, b=obj.units)
            raise TypeError("Expected Quantity or QuantityWrapper instance.")

        def serialize(instance):
            base = {"value": instance.value, "units": instance.units.name}
            return {**base, **instance.extra_fields}

        return core_schema.no_info_plain_validator_function(
            validate_quantity_type,
            json_schema_input_schema=core_schema.model_fields_schema(
                {
                    "value": core_schema.list_schema(items_schema=core_schema.float_schema()),
                    "units": core_schema.str_schema(),
                },
                extras_schema=core_schema.any_schema(),
            ),
            serialization=core_schema.plain_serializer_function_ser_schema(
                serialize, return_schema=core_schema.dict_schema()
            ),
        )