In my initial post, I wrote:
However, I am wondering if there might not be a better way to do this argument validation. Potentially using a third party library. I guess my point is that I am feeling that I might be reinventing the wheel and that people smarte than me likely faced this issue before and probably implemented a better solution.
I found that I could use either attrs, pydantic, or beartype to do what I wanted so I implemented solutions using each to test them and decide for myself what seems to make more sense for my project. typeguard was another alternative which I haven't tested.
Below are the three implementations.
attrs
import attrs
@attrs.define
class GetAttrs:
id: str | list[str] = attrs.field(
validator=attrs.validators.or_(
attrs.validators.instance_of(str),
attrs.validators.deep_iterable(
member_validator=attrs.validators.instance_of(str),
iterable_validator=attrs.validators.instance_of(list),
),
)
)
id_type: str = attrs.field(validator=attrs.validators.instance_of(str))
ctry_code: str = attrs.field(default = "", validator=attrs.validators.matches_re(r"[A-Z]{3}$|^LOCAL$|^$"))
is_alive: bool = attrs.field(default = False, validator=attrs.validators.instance_of(bool))
def get(self, **kwargs):
# doing some stuff
object1 = Object(kwargs)
# doing some other stuff to get data
return data
GetObj = GetAttrs(id=["id1", "id2"], id_type="myidtype")
GetObj.get(kv1={"k1": 1, "k2": 2}, kv2="test")
My main issue with this solution is that I have to pass kwargs to the method get() and not at the instanciation of GetAttrs. From what I found, I could pass kwarg at the instanciation of GetAttrs but it does not seems super clean.
However, I good point is that as I am now planning to use attrs in my modules, using it here would not lead to multiplication of third party libraries.
pydantic
from typing import Literal
from pydantic import Field, validate_call
type Liststr = list[str]
@validate_call
def get_pydantic(id: str | Liststr,
id_type: str,
ctry_code: str = Field(default="", pattern=r"^[A-Z]{3}$|^LOCAL$|^$"),
is_alive: bool = False,
**kwargs ):
# doing some stuff
object1 = Object(kwargs)
# doing some other stuff to get data
return data
get_pydantic("id"=["id1", "id2"], id_type="myidtype", kv1={"k1": 1, "k2": 2}, kv2="test")
Works quite well and I have no real concern with this solution. However, the decorator @validate_call is a very tiny part of pydantic, which does many other things, so it might make sense to use something dedicated to argument validation with a bit less scope.
beartype
from typing import Annotated, Literal, Union
import re
from beartype import beartype
from beartype.cave import IterableType
from beartype.vale import Is
IsCtry = Annotated[str, Is[lambda string: re.fullmatch(r"[A-Z]{3}$|^LOCAL$|^$", string)]]
@beartype
def get_beartype(id: Union[str, IterableType[str]],
id_type: str,
item_type: str,
ctry_code: IsCtry = "",
is_alive: bool = False,
**kwargs
):
# doing some stuff
object1 = Object(kwargs)
# doing some other stuff to get data
return data
get_beartype(id=["id1", "id2"], id_type="myidtype", kv1={"k1": 1, "k2": 2}, kv2="test")
Works quite well and I found it quite elegant. I do not see any strong issue and as I want to use attrs in my module, I have the impression that I don't have the strong overlap with it that pydantic might have. So I have decided to use it as my solution.
Hope that helps anyone who might have a similar problem. Further any feedback on how thos implementations could be improved is very welcome.
