``attrs`` has added provisional support for static typing in ``pyright`` version 1.1.135 via the `dataclass_transforms specification <https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md>`.

Both the ``pyright`` specification and ``attrs`` implementation may change in future versions of both projects.

Your constructive feedback is welcome in both `attrs#795<https://github.com/python-attrs/attrs/issues/795>`_ and `pyright#1782<https://github.com/microsoft/pyright/discussions/1782>`_.

Another common use case is to overwrite ``attrs``'s defaults.

Unfortunately, this currently `confuses<https://github.com/python/mypy/issues/5406>`_ mypy's ``attrs`` plugin.

Mypy

Unfortunately, decorator wrapping currently `confuses<https://github.com/python/mypy/issues/5406>`_ mypy's ``attrs`` plugin.

At the moment, the best workaround is to hold your nose, write a fake mypy plugin, and mutate a bunch of global variables::

Please note that it is currently *impossible* to let mypy know that you've changed defaults like *eq* or *order*.

You can only use this trick to tell mypy that a class is actually an ``attrs`` class.

Pyright

Generic decorator wrapping is supported in ``pyright`` via the provisionaldataclass_transform_ specification.

For a custom wrapping of the form::

This is implemented via a ``__dataclass_transform__`` type decorator in the custom extension's ``.pyi`` of the form::

..note::

``dataclass_transform`` is supported provisionally as of ``pyright`` 1.1.135.

Both the ``pyright``dataclass_transform_ specification and ``attrs`` implementation may changed in future versions.

Types

>>>json.dumps(data)

.. _dataclass_transform:https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md

When this happens, ``attrs`` will simply put these string literals into the ``type`` attributes.

If you need to resolve these to real types, you can call `attr.resolve_types` which will update the attribute in place.

In practice though, types show their biggest usefulness in combination with tools likemypy_orpytype_ that both have dedicated support for ``attrs`` classes.

In practice though, types show their biggest usefulness in combination with tools likemypy_,pytype_orpyright_ that have dedicated support for ``attrs`` classes.

The addition of static types is certainly one of the most exciting features in the Python ecosystem and helps you writing *correct* and *verified self-documenting* code.

If you don't know where to start, Carl Meyer gave a great talk on `Type-checked Python in the Real World<https://www.youtube.com/watch?v=pMgmKJyWKn8>`_ at PyCon US 2018 that will help you to get started in no time.

mypy

The addition of static types is certainly one of the most exciting features in the Python ecosystem and helps you writing *correct* and *verified self-documenting* code.

pyright

If you don't know where to start, Carl Meyer gave a great talk on `Type-checked Python in the Real World<https://www.youtube.com/watch?v=pMgmKJyWKn8>`_ at PyCon US 2018 that will help you to get started in no time.

``attrs`` provides support forpyright_ though thedataclass_transform_ specification.

This provides static type inference for a subset of ``attrs`` equivalent to standard-library ``dataclasses``,

and requires explicit type annotations using the:ref:`next-gen` or ``@attr.s(auto_attribs=True)`` API.

Given the following definition, ``pyright`` will generate static type signatures for ``SomeClass`` attribute access, ``__init__``, ``__eq__``, and comparison methods::

..note::

``dataclass_transform``-based types are supported provisionally as of ``pyright`` 1.1.135 and ``attrs`` 21.1.

Both the ``pyright``dataclass_transform_ specification and ``attrs`` implementation may changed in future versions.

The ``pyright`` inferred types are a subset of those supported by ``mypy``, including:

- The generated ``__init__`` signature only includes the attribute type annotations,

and does not include attribute ``converter`` types.

- The ``attr.frozen`` decorator is not typed with frozen attributes, which are properly typed via ``attr.define(frozen=True)``.

Your constructive feedback is welcome in both `attrs#795<https://github.com/python-attrs/attrs/issues/795>`_ and `pyright#1782<https://github.com/microsoft/pyright/discussions/1782>`_.

.. _mypy:http://mypy-lang.org

.. _pytype:https://google.github.io/pytype/

.. _pyright:https://github.com/microsoft/pyright

.. _dataclass_transform:https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md

takes_self:bool= ...,

)->_T: ...

def__dataclass_transform__(

*,

eq_default:bool=True,

order_default:bool=False,

kw_only_default:bool=False,

field_descriptors:Tuple[Union[type,Callable[...,Any]], ...]= (()),

)->Callable[[_T],_T]: ...

classAttribute(Generic[_T]):

name:str

on_setattr:Optional[_OnSetAttrArgType]= ...,

)->Any: ...

defattrs(

maybe_cls:_C,

these:Optional[Dict[str,Any]]= ...,

field_transformer:Optional[_FieldTransformer]= ...,

)->_C: ...

defattrs(

maybe_cls:None= ...,

these:Optional[Dict[str,Any]]= ...,

field_transformer:Optional[_FieldTransformer]= ...,

)->Callable[[_C],_C]: ...

defdefine(

maybe_cls:_C,

*,

field_transformer:Optional[_FieldTransformer]= ...,

)->_C: ...

defdefine(

maybe_cls:None= ...,

*,

classDefine:

a:str

b:int

reveal_type(Define.__init__)# noqa

classDefineConverter:

with_converter:int=attr.field(converter=int)

reveal_type(DefineConverter.__init__)# noqa

classFrozen:

a:str

d=Frozen("a")

d.a="new"

reveal_type(d.a)# noqa

classFrozenDefine:

a:str

d2=FrozenDefine("a")

d2.a="new"

reveal_type(d2.a)# noqa

importos.path

ifsys.version_info< (3,6):

else:

_found_pyright=shutil.which("pyright")

classPyrightDiagnostic(object):

severity=attr.ib()

message=attr.ib()

deftest_pyright_baseline():

test_file=os.path.dirname(__file__)+"/dataclass_transform_example.py"

pyright=subprocess.run(

["pyright","--outputjson",str(test_file)],capture_output=True

)

pyright_result=json.loads(pyright.stdout)

diagnostics=set(

PyrightDiagnostic(d["severity"],d["message"])

fordinpyright_result["generalDiagnostics"]

)

expected_diagnostics= {

PyrightDiagnostic(

severity="information",

' "(self: Define, a: str, b: int) -> None"',

),

PyrightDiagnostic(

severity="information",

'"(self: DefineConverter, with_converter: int) -> None"',

),

PyrightDiagnostic(

severity="information",

message='Type of "d.a" is "Literal[\'new\']"',

),

PyrightDiagnostic(

severity="error",

'"FrozenDefine"\n\xa0\xa0"FrozenDefine" is frozen',

),

PyrightDiagnostic(

severity="information",

message='Type of "d2.a" is "Literal[\'new\']"',

),

}

3.6: py36

3.7: py37, docs

3.8: py38, lint, manifest, typing, changelog

3.9: py39

3.9: py39, pyright

3.10: py310

pypy2: pypy2

pypy3: pypy3

envlist = typing,lint,py27,py35,py36,py37,py38,py39,py310,pypy,pypy3,manifest,docs,pypi-description,changelog,coverage-report

envlist = typing,lint,py27,py35,py36,py37,py38,py39,py310,pypy,pypy3,pyright,manifest,docs,pypi-description,changelog,coverage-report

isolated_build = True

commands =

mypy src/attr/__init__.pyi src/attr/_version_info.pyi src/attr/converters.pyi src/attr/exceptions.pyi src/attr/filters.pyi src/attr/setters.pyi src/attr/validators.pyi

mypy tests/typing_example.py

basepython = python3.9

deps = nodeenv

commands =

nodeenv --prebuilt --node=lts --force {envdir}

npm install -g --no-package-lock --no-save pyright@1.1.135

pytest tests/test_pyright.py -vv