use metadata in hooks

[amirreza8002]

hi
so as you know the field function in attrs takes a metadata argument
i qas thinking of using that to provide some dynamic data to my hooks
is this possible?

i can't see anything related to it, sorry if it is written somewhere

[Tinche]

There're no special provisions for it but I don't think any are necessary. What exactly did you have in mind?

[amirreza8002]

I'm experimenting integrating cattrs with django
django takes some parameters in it's data fields

i was looking for different ways to mimic a similar behavior

most of could be done with validators, but some need to be enforced in hooks
e.g: decimal field needs max_digits https://github.com/django/django/blob/stable/5.2.x/django/forms/fields.py#L413

[Tinche]

I don't know Django that well; what exactly are we trying to do here? Model a form using an attrs class (or dataclass)?

[amirreza8002]

hi
sorry for delay

forms are a way to work with data in template engines (jinja2, django template engine)

i'm trying to provide a serializer quivelent of that

so developer could write something like

@define
class User:
    username: CharField
    email: EmailField
    password: PasswordField

where EmailField and other fields are classes provided by me
each of them has specific hooks for that data.

and there will be validators that will be used like any other attrs validator

but, sometimes django enforces a validation to be run
so in these cases i don't want to leave it to the developer to add it to validators list

i came up with this way to do this:

class EmailField(str):
    pass


@converter.register_structure_hook
def email_structure(val, _) -> EmailField:
    try:
        validators.validate_email(val)
    except ValidationError as e:
        raise ValueError(e.message)
    return val

which works

but in the case of DecimalField, and others, i need to pass in a value to the enforced validator, and te value needs to be provided by developer

[Tinche]

Ok, I think I'm getting what you're looking for. There are a couple of ways this could be done. Let's start with the simplest and go from there.

Instead of putting this data into the field metadata, can we put it into the type itself? Imagine something like this:

from decimal import Decimal
from typing import Annotated, get_args

from attrs import define, frozen

from cattrs import Converter
from cattrs._compat import is_annotated


@frozen
class DecimalParams:
    max_digits: int | None = None


@define
class Model:
    a: Annotated[Decimal, DecimalParams(max_digits=3)]


conv = Converter()


def structure_decimal(val, type) -> Decimal:
    max_digits = get_args(type)[1].max_digits
    value = Decimal(val)
    digit_tuple, exponent = value.as_tuple()[1:]
    if exponent >= 0:
        digits = len(digit_tuple)
        if digit_tuple != (0,):
            digits += exponent
    else:
        digits = abs(exponent) if abs(exponent) > len(digit_tuple) else len(digit_tuple)

    if digits > max_digits:
        raise Exception("")

    return value


conv.register_structure_hook_func(
    lambda t: is_annotated(t) and get_args(t)[0] is Decimal, structure_decimal
)

print(conv.structure({"a": "1.023"}, Model))

The users would need to mark the type as Annotated[Decimal, DecimalParams()] instead of just Decimal. We then register a hook for that type specifically and handle it.

There's a way to also handle it via field metadata, but it's a little more complex.

[amirreza8002]

hi 👋
thanks for the elaborate explanation 🙌

if it's not a problem, could use give me an idea on how the other approach would look like?

[Tinche]

Of course, but it might take me a couple days due to some urgent life stuff.