How to annotate attrs field with validator?

To make it happy, cast. field is considerably complicated, your field returns a str thanks to this overload:

... # other overloads
# This form catches an explicit None or no default and infers the type from the
# other arguments.
@overload
def field(
    *,
    default: None = ...,
    validator: Optional[_ValidatorArgType[_T]] = ...,
    repr: _ReprArgType = ...,
    hash: Optional[bool] = ...,
    init: bool = ...,
    metadata: Optional[Mapping[Any, Any]] = ...,
    converter: Optional[_ConverterType] = ...,
    factory: Optional[Callable[[], _T]] = ...,
    kw_only: bool = ...,
    eq: Optional[_EqOrderType] = ...,
    order: Optional[_EqOrderType] = ...,
    on_setattr: Optional[_OnSetAttrArgType] = ...,
    alias: Optional[str] = ...,
) -> _T: ...

It basically says "when validators is a [sequence of or one of] validators working on some type T, then field returns T".

So, you pass a validator that works on str, and thus field type is str as well. NewType("UserID", str) is not a subtype of str, so this assignment fails. You have two major options:

• cast to desired type:

  from typing import cast
  
  ...
  @frozen
  class Order:
       id: UserId = cast(str, field(validator=validators.matches_re("^\d+$")))
  

• create your own validator. You don't need to replicate the logic, only change the signature and call original implementation with type: ignore or casts.

  from typing import TYPE_CHECKING, Callable, Match, Optional, Pattern, Union, cast
  if TYPE_CHECKING:
       from attr import _ValidatorType
  
  def userid_matches_re(
       regex: Union[Pattern[str], str],
       flags: int = ...,
       func: Optional[
           Callable[[str, str, int], Optional[Match[str]]]
       ] = ...,
  ) -> '_ValidatorType[UserID]':
       return cast('_ValidatorType[UserID]', validators.matches_re(regex, flags, func))
  

  ... and use it in your class instead of validators.matches_re. The signature above is stolen from stubs with AnyStr replaced with str, because you don't allow bytes anyway.

I'd recommend the first variant, because another solution is just more boilerplate with the same cast as a result, it gives you no more safety. However, it may be viable if you have many fields with this validator.