开源软件构建与测试

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 11

_service:tar_scm:python-attrs.spec Changed

_service:tar_scm:0001-Fix-minor-stub-issues-1072.patch Deleted

@@ -1,60 +0,0 @@
-From b9f35eb2f25fa835ce61af067c20029216a0aeeb Mon Sep 17 00:00:00 2001
-From: Hynek Schlawack <hs@ox.cx>
-Date: Tue, 20 Dec 2022 15:10:12 +0100
-Subject: PATCH Fix minor stub issues (#1072)
-
----
- src/attr/__init__.pyi   | 8 ++++----
- src/attr/converters.pyi | 2 +-
- src/attr/setters.pyi    | 2 +-
- 3 files changed, 6 insertions(+), 6 deletions(-)
-
-diff --git a/src/attr/__init__.pyi b/src/attr/__init__.pyi
-index baa5b2a..42a2ee2 100644
---- a/src/attr/__init__.pyi
-+++ b/src/attr/__init__.pyi
-@@ -48,17 +48,17 @@ _T = TypeVar("_T")
- _C = TypeVar("_C", bound=type)
- 
- _EqOrderType = Unionbool, CallableAny, Any
--_ValidatorType = CallableAny, Attribute_T, _T, Any
-+_ValidatorType = CallableAny, "Attribute_T", _T, Any
- _ConverterType = CallableAny, Any
--_FilterType = CallableAttribute_T, _T, bool
-+_FilterType = Callable"Attribute_T", _T, bool
- _ReprType = CallableAny, str
- _ReprArgType = Unionbool, _ReprType
--_OnSetAttrType = CallableAny, AttributeAny, Any, Any
-+_OnSetAttrType = CallableAny, "AttributeAny", Any, Any
- _OnSetAttrArgType = Union
-     _OnSetAttrType, List_OnSetAttrType, setters._NoOpType
- 
- _FieldTransformer = Callable
--    type, ListAttributeAny, ListAttributeAny
-+    type, List"AttributeAny", List"AttributeAny"
- 
- # FIXME: in reality, if multiple validators are passed they must be in a list
- # or tuple, but those are invariant and so would prevent subtypes of
-diff --git a/src/attr/converters.pyi b/src/attr/converters.pyi
-index 0f58088..5abb49f 100644
---- a/src/attr/converters.pyi
-+++ b/src/attr/converters.pyi
-@@ -1,4 +1,4 @@
--from typing import Callable, Optional, TypeVar, overload
-+from typing import Callable, TypeVar, overload
- 
- from . import _ConverterType
- 
-diff --git a/src/attr/setters.pyi b/src/attr/setters.pyi
-index 3f5603c..72f7ce4 100644
---- a/src/attr/setters.pyi
-+++ b/src/attr/setters.pyi
-@@ -1,4 +1,4 @@
--from typing import Any, NewType, NoReturn, TypeVar, cast
-+from typing import Any, NewType, NoReturn, TypeVar
- 
- from . import Attribute, _OnSetAttrType
- 
--- 
-2.33.0
-

_service:tar_scm:0001-Fix-type-docstring.patch Deleted

_service:tar_scm:0001-Fix-typo.patch Deleted

_service:tar_scm:0001-Update-.gitignore.patch Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/.github/workflows/main.yml Deleted

@@ -1,114 +0,0 @@
----
-name: CI
-
-on:
-  push:
-    branches: "main"
-    tags: "*"
-  pull_request:
-    branches: "main"
-  workflow_dispatch:
-
-env:
-  FORCE_COLOR: "1"  # Make tools pretty.
-  TOX_TESTENV_PASSENV: FORCE_COLOR
-  PYTHON_LATEST: "3.10"
-
-
-jobs:
-  tests:
-    name: tox on ${{ matrix.python-version }}
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: "3.5", "3.6", "3.7", "3.8", "3.9", "3.10", "3.11.0-beta - 3.11", "pypy-3.7", "pypy-3.8"
-
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: "Install dependencies"
-        run: |
-          python -VV
-          python -m site
-          python -m pip install --upgrade pip setuptools wheel
-          python -m pip install --upgrade virtualenv tox tox-gh-actions
-
-      - run: "python -m tox"
-
-      - name: Upload coverage data
-        uses: actions/upload-artifact@v3
-        with:
-          name: coverage-data
-          path: ".coverage.*"
-          if-no-files-found: ignore
-
-
-  coverage:
-    runs-on: ubuntu-latest
-    needs: tests
-
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
-        with:
-          # Use latest Python, so it understands all syntax.
-          python-version: ${{env.PYTHON_LATEST}}
-
-      - run: python -m pip install --upgrade coveragetoml
-
-      - name: Download coverage data
-        uses: actions/download-artifact@v3
-        with:
-          name: coverage-data
-
-      - name: Combine coverage and fail if it's <100%.
-        run: |
-          python -m coverage combine
-          python -m coverage html --skip-covered --skip-empty
-          python -m coverage report --fail-under=100
-
-      - name: Upload HTML report if check failed.
-        uses: actions/upload-artifact@v3
-        with:
-          name: html-report
-          path: htmlcov
-        if: ${{ failure() }}
-
-
-  package:
-    name: Build & verify package
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
-        with:
-          python-version: ${{env.PYTHON_LATEST}}
-
-      - run: python -m pip install build twine check-wheel-contents
-      - run: python -m build --sdist --wheel .
-      - run: ls -l dist
-      - run: check-wheel-contents dist/*.whl
-      - name: Check long_description
-        run: python -m twine check dist/*
-
-
-  install-dev:
-    name: Verify dev env
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: "ubuntu-latest", "windows-latest"
-
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
-        with:
-          python-version: ${{env.PYTHON_LATEST}}
-      - run: python -m pip install -e .dev
-      - run: python -c 'import attr; print(attr.__version__)'

_service:tar_scm:attrs-22.1.0.tar.gz/.readthedocs.yml Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/AUTHORS.rst Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/CHANGELOG.rst Deleted

@@ -1,1069 +0,0 @@
-Changelog
-=========
-
-Versions follow `CalVer <https://calver.org>`_ with a strict backwards-compatibility policy.
-
-The **first number** of the version is the year.
-The **second number** is incremented with each release, starting at 1 for each year.
-The **third number** is when we need to start branches for older releases (only for emergencies).
-
-Put simply, you shouldn't ever be afraid to upgrade ``attrs`` if you're only using its public APIs.
-Whenever there is a need to break compatibility, it is announced here in the changelog, and raises a ``DeprecationWarning`` for a year (if possible) before it's finally really broken.
-
-.. warning::
-
-   The structure of the `attrs.Attribute` class is exempt from this rule.
-   It *will* change in the future, but since it should be considered read-only, that shouldn't matter.
-
-   However if you intend to build extensions on top of ``attrs`` you have to anticipate that.
-
-.. towncrier release notes start
-
-22.1.0 (2022-07-28)
--------------------
-
-Backwards-incompatible Changes
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- Python 2.7 is not supported anymore.
-
-  Dealing with Python 2.7 tooling has become too difficult for a volunteer-run project.
-
-  We have supported Python 2 more than 2 years after it was officially discontinued and feel that we have paid our dues.
-  All version up to 21.4.0 from December 2021 remain fully functional, of course.
-  `#936 <https://github.com/python-attrs/attrs/issues/936>`_
-- The deprecated ``cmp`` attribute of ``attrs.Attribute`` has been removed.
-  This does not affect the *cmp* argument to ``attr.s`` that can be used as a shortcut to set *eq* and *order* at the same time.
-  `#939 <https://github.com/python-attrs/attrs/issues/939>`_
-
-
-Changes
-^^^^^^^
-
-- Instantiation of frozen slotted classes is now faster.
-  `#898 <https://github.com/python-attrs/attrs/issues/898>`_
-- If an ``eq`` key is defined, it is also used before hashing the attribute.
-  `#909 <https://github.com/python-attrs/attrs/issues/909>`_
-- Added ``attrs.validators.min_len()``.
-  `#916 <https://github.com/python-attrs/attrs/issues/916>`_
-- ``attrs.validators.deep_iterable()``'s *member_validator* argument now also accepts a list of validators and wraps them in an ``attrs.validators.and_()``.
-  `#925 <https://github.com/python-attrs/attrs/issues/925>`_
-- Added missing type stub re-imports for ``attrs.converters`` and ``attrs.filters``.
-  `#931 <https://github.com/python-attrs/attrs/issues/931>`_
-- Added missing stub for ``attr(s).cmp_using()``.
-  `#949 <https://github.com/python-attrs/attrs/issues/949>`_
-- ``attrs.validators._in()``'s ``ValueError`` is not missing the attribute, expected options, and the value it got anymore.
-  `#951 <https://github.com/python-attrs/attrs/issues/951>`_
-- Python 3.11 is now officially supported.
-  `#969 <https://github.com/python-attrs/attrs/issues/969>`_
-
-
-----
-
-
-21.4.0 (2021-12-29)
--------------------
-
-Changes
-^^^^^^^
-
-- Fixed the test suite on PyPy3.8 where ``cloudpickle`` does not work.
-  `#892 <https://github.com/python-attrs/attrs/issues/892>`_
-- Fixed ``coverage report`` for projects that use ``attrs`` and don't set a ``--source``.
-  `#895 <https://github.com/python-attrs/attrs/issues/895>`_,
-  `#896 <https://github.com/python-attrs/attrs/issues/896>`_
-
-
-----
-
-
-21.3.0 (2021-12-28)
--------------------
-
-Backward-incompatible Changes
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- When using ``@define``, converters are now run by default when setting an attribute on an instance -- additionally to validators.
-  I.e. the new default is ``on_setattr=attrs.setters.convert, attrs.setters.validate``.
-
-  This is unfortunately a breaking change, but it was an oversight, impossible to raise a ``DeprecationWarning`` about, and it's better to fix it now while the APIs are very fresh with few users.
-  `#835 <https://github.com/python-attrs/attrs/issues/835>`_,
-  `#886 <https://github.com/python-attrs/attrs/issues/886>`_
-- ``import attrs`` has finally landed!
-  As of this release, you can finally import ``attrs`` using its proper name.
-
-  Not all names from the ``attr`` namespace have been transferred; most notably ``attr.s`` and ``attr.ib`` are missing.
-  See ``attrs.define`` and ``attrs.field`` if you haven't seen our next-generation APIs yet.
-  A more elaborate explanation can be found `On The Core API Names <https://www.attrs.org/en/latest/names.html>`_
-
-  This feature is at least for one release **provisional**.
-  We don't *plan* on changing anything, but such a big change is unlikely to go perfectly on the first strike.
-
-  The API docs have been mostly updated, but it will be an ongoing effort to change everything to the new APIs.
-  Please note that we have **not** moved -- or even removed -- anything from ``attr``!
-
-  Please do report any bugs or documentation inconsistencies!
-  `#887 <https://github.com/python-attrs/attrs/issues/887>`_
-
-
-Changes
-^^^^^^^
-
-- ``attr.asdict(retain_collection_types=False)`` (default) dumps collection-esque keys as tuples.
-  `#646 <https://github.com/python-attrs/attrs/issues/646>`_,
-  `#888 <https://github.com/python-attrs/attrs/issues/888>`_
-- ``__match_args__`` are now generated to support Python 3.10's
-  `Structural Pattern Matching <https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching>`_.
-  This can be controlled by the ``match_args`` argument to the class decorators on Python 3.10 and later.
-  On older versions, it is never added and the argument is ignored.
-  `#815 <https://github.com/python-attrs/attrs/issues/815>`_
-- If the class-level *on_setattr* is set to ``attrs.setters.validate`` (default in ``@define`` and ``@mutable``) but no field defines a validator, pretend that it's not set.
-  `#817 <https://github.com/python-attrs/attrs/issues/817>`_
-- The generated ``__repr__`` is significantly faster on Pythons with f-strings.
-  `#819 <https://github.com/python-attrs/attrs/issues/819>`_
-- Attributes transformed via ``field_transformer`` are wrapped with ``AttrsClass`` again.
-  `#824 <https://github.com/python-attrs/attrs/issues/824>`_
-- Generated source code is now cached more efficiently for identical classes.
-  `#828 <https://github.com/python-attrs/attrs/issues/828>`_
-- Added ``attrs.converters.to_bool()``.
-  `#830 <https://github.com/python-attrs/attrs/issues/830>`_
-- ``attrs.resolve_types()`` now resolves types of subclasses after the parents are resolved.
-  `#842 <https://github.com/python-attrs/attrs/issues/842>`_
-  `#843 <https://github.com/python-attrs/attrs/issues/843>`_
-- Added new validators: ``lt(val)`` (< val), ``le(va)`` (≤ val), ``ge(val)`` (≥ val), ``gt(val)`` (> val), and ``maxlen(n)``.
-  `#845 <https://github.com/python-attrs/attrs/issues/845>`_
-- ``attrs`` classes are now fully compatible with `cloudpickle <https://github.com/cloudpipe/cloudpickle>`_ (no need to disable ``repr`` anymore).
-  `#857 <https://github.com/python-attrs/attrs/issues/857>`_
-- Added new context manager ``attrs.validators.disabled()`` and functions ``attrs.validators.(set|get)_disabled()``.
-  They deprecate ``attrs.(set|get)_run_validators()``.
-  All functions are interoperable and modify the same internal state.
-  They are not – and never were – thread-safe, though.
-  `#859 <https://github.com/python-attrs/attrs/issues/859>`_
-- ``attrs.validators.matches_re()`` now accepts pre-compiled regular expressions in addition to pattern strings.
-  `#877 <https://github.com/python-attrs/attrs/issues/877>`_
-
-
-----
-
-
-21.2.0 (2021-05-07)
--------------------
-
-Backward-incompatible Changes
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-- We had to revert the recursive feature for ``attr.evolve()`` because it broke some use-cases -- sorry!
-  `#806 <https://github.com/python-attrs/attrs/issues/806>`_
-- Python 3.4 is now blocked using packaging metadata because ``attrs`` can't be imported on it anymore.
-  To ensure that 3.4 users can keep installing  ``attrs`` easily, we will `yank <https://pypi.org/help/#yanked>`_ 21.1.0 from PyPI.
-  This has **no** consequences if you pin ``attrs`` to 21.1.0.
-  `#807 <https://github.com/python-attrs/attrs/issues/807>`_
-
-
-----
-
-
-21.1.0 (2021-05-06)
--------------------
-
-Deprecations
-^^^^^^^^^^^^
-
-- The long-awaited, much-talked-about, little-delivered ``import attrs`` is finally upon us!
-
-  Since the NG APIs have now been proclaimed stable, the **next** release of ``attrs`` will allow you to actually ``import attrs``.
-  We're taking this opportunity to replace some defaults in our APIs that made sense in 2015, but don't in 2021.
-
-  So please, if you have any pet peeves about defaults in ``attrs``'s APIs, *now* is the time to air your grievances in #487!
-  We're not gonna get such a chance for a second time, without breaking our backward-compatibility guarantees, or long deprecation cycles.
-  Therefore, speak now or forever hold you peace!
-  `#487 <https://github.com/python-attrs/attrs/issues/487>`_
-- The *cmp* argument to ``attr.s()`` and `attr.ib()` has been **undeprecated**
-  It will continue to be supported as syntactic sugar to set *eq* and *order* in one go.
-
-  I'm terribly sorry for the hassle around this argument!
-  The reason we're bringing it back is it's usefulness regarding customization of equality/ordering.
-
-  The ``cmp`` attribute and argument on ``attr.Attribute`` remains deprecated and will be removed later this year.
-  `#773 <https://github.com/python-attrs/attrs/issues/773>`_
-
-
-Changes
-^^^^^^^
-
-- It's now possible to customize the behavior of ``eq`` and ``order`` by passing in a callable.
-  `#435 <https://github.com/python-attrs/attrs/issues/435>`_,
-  `#627 <https://github.com/python-attrs/attrs/issues/627>`_
-- The instant favorite next-generation APIs are not provisional anymore!
-
-  They are also officially supported by Mypy as of their `0.800 release <https://mypy-lang.blogspot.com/2021/01/mypy-0800-released.html>`_.

_service:tar_scm:attrs-22.1.0.tar.gz/README.rst Deleted

@@ -1,127 +0,0 @@
-.. raw:: html
-
-   <p align="center">
-      <a href="https://www.attrs.org/">
-         <img src="./docs/_static/attrs_logo.svg" width="35%" alt="attrs" />
-      </a>
-   </p>
-   <p align="center">
-      <a href="https://www.attrs.org/en/stable/?badge=stable">
-          <img src="https://img.shields.io/badge/Docs-Read%20The%20Docs-black" alt="Documentation" />
-      </a>
-      <a href="https://github.com/python-attrs/attrs/blob/main/LICENSE">
-         <img src="https://img.shields.io/badge/license-MIT-C06524" alt="License: MIT" />
-      </a>
-      <a href="https://pypi.org/project/attrs/">
-         <img src="https://img.shields.io/pypi/v/attrs" />
-      </a>
-      <a href="https://pepy.tech/project/attrs">
-         <img src="https://static.pepy.tech/personalized-badge/attrs?period=month&units=international_system&left_color=grey&right_color=blue&left_text=Downloads%20/%20Month" alt="Downloads per month" />
-      </a>
-   </p>
-
-.. teaser-begin
-
-``attrs`` is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka `dunder methods <https://www.attrs.org/en/latest/glossary.html#term-dunder-methods>`_).
-`Trusted by NASA <https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/personalizing-your-profile#list-of-qualifying-repositories-for-mars-2020-helicopter-contributor-achievement>`_ for Mars missions since 2020!
-
-Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
-
-.. teaser-end
-
-For that, it gives you a class decorator and a way to declaratively define the attributes on that class:
-
-.. -code-begin-
-
-.. code-block:: pycon
-
-   >>> from attrs import asdict, define, make_class, Factory
-
-   >>> @define
-   ... class SomeClass:
-   ...     a_number: int = 42
-   ...     list_of_numbers: listint = Factory(list)
-   ...
-   ...     def hard_math(self, another_number):
-   ...         return self.a_number + sum(self.list_of_numbers) * another_number
-
-
-   >>> sc = SomeClass(1, 1, 2, 3)
-   >>> sc
-   SomeClass(a_number=1, list_of_numbers=1, 2, 3)
-
-   >>> sc.hard_math(3)
-   19
-   >>> sc == SomeClass(1, 1, 2, 3)
-   True
-   >>> sc != SomeClass(2, 3, 2, 1)
-   True
-
-   >>> asdict(sc)
-   {'a_number': 1, 'list_of_numbers': 1, 2, 3}
-
-   >>> SomeClass()
-   SomeClass(a_number=42, list_of_numbers=)
-
-   >>> C = make_class("C", "a", "b")
-   >>> C("foo", "bar")
-   C(a='foo', b='bar')
-
-
-After *declaring* your attributes, ``attrs`` gives you:
-
-- a concise and explicit overview of the class's attributes,
-- a nice human-readable ``__repr__``,
-- equality-checking methods,
-- an initializer,
-- and much more,
-
-*without* writing dull boilerplate code again and again and *without* runtime performance penalties.
-
-**Hate type annotations**!?
-No problem!
-Types are entirely **optional** with ``attrs``.
-Simply assign ``attrs.field()`` to the attributes instead of annotating them with types.
-
-----
-
-This example uses ``attrs``'s modern APIs that have been introduced in version 20.1.0, and the ``attrs`` package import name that has been added in version 21.3.0.
-The classic APIs (``@attr.s``, ``attr.ib``, plus their serious-business aliases) and the ``attr`` package import name will remain **indefinitely**.
-
-Please check out `On The Core API Names <https://www.attrs.org/en/latest/names.html>`_ for a more in-depth explanation.
-
-
-Data Classes
-============
-
-On the tin, ``attrs`` might remind you of ``dataclasses`` (and indeed, ``dataclasses`` `are a descendant <https://hynek.me/articles/import-attrs/>`_ of ``attrs``).
-In practice it does a lot more and is more flexible.
-For instance it allows you to define `special handling of NumPy arrays for equality checks <https://www.attrs.org/en/stable/comparison.html#customization>`_, or allows more ways to `plug into the initialization process <https://www.attrs.org/en/stable/init.html#hooking-yourself-into-initialization>`_.
-
-For more details, please refer to our `comparison page <https://www.attrs.org/en/stable/why.html#data-classes>`_.
-
-.. -project-information-
-
-Project Information
-===================
-
-- **License**: `MIT <https://choosealicense.com/licenses/mit/>`_
-- **PyPI**: https://pypi.org/project/attrs/
-- **Source Code**: https://github.com/python-attrs/attrs
-- **Documentation**:  https://www.attrs.org/
-- **Changelog**: https://www.attrs.org/en/stable/changelog.html
-- **Get Help**: please use the ``python-attrs`` tag on `StackOverflow <https://stackoverflow.com/questions/tagged/python-attrs>`_
-- **Third-party Extensions**: https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs
-- **Supported Python Versions**: 3.5 and later (last 2.7-compatible release is `21.4.0 <https://pypi.org/project/attrs/21.4.0/>`_)
-
-If you'd like to contribute to ``attrs`` you're most welcome and we've written `a little guide <https://github.com/python-attrs/attrs/blob/main/.github/CONTRIBUTING.md>`_ to get you started!
-
-
-``attrs`` for Enterprise
-------------------------
-
-Available as part of the Tidelift Subscription.
-
-The maintainers of ``attrs`` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
-Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
-`Learn more. <https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo>`_

_service:tar_scm:attrs-22.1.0.tar.gz/changelog.d/towncrier_template.rst Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/docs/changelog.rst Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/docs/comparison.rst Deleted

@@ -1,66 +0,0 @@
-Comparison
-==========
-
-By default, two instances of ``attrs`` classes are equal if all their fields are equal.
-For that, ``attrs`` writes ``__eq__`` and ``__ne__`` methods for you.
-
-Additionally, if you pass ``order=True`` (which is the default if you use the `attr.s` decorator), ``attrs`` will also create a full set of ordering methods that are based on the defined fields: ``__le__``, ``__lt__``, ``__ge__``, and ``__gt__``.
-
-
-.. _custom-comparison:
-
-Customization
--------------
-
-As with other features, you can exclude fields from being involved in comparison operations:
-
-.. doctest::
-
-   >>> from attr import define, field
-
-   >>> @define
-   ... class C:
-   ...     x: int
-   ...     y: int = field(eq=False)
-
-   >>> C(1, 2) == C(1, 3)
-   True
-
-Additionally you can also pass a *callable* instead of a bool to both *eq* and *order*.
-It is then used as a key function like you may know from `sorted`:
-
-.. doctest::
-
-   >>> from attr import define, field
-
-   >>> @define
-   ... class S:
-   ...     x: str = field(eq=str.lower)
-
-   >>> S("foo") == S("FOO")
-   True
-
-   >>> @define(order=True)
-   ... class C:
-   ...     x: str = field(order=int)
-
-   >>> C("10") > C("2")
-   True
-
-This is especially useful when you have fields with objects that have atypical comparison properties.
-Common examples of such objects are `NumPy arrays <https://github.com/python-attrs/attrs/issues/435>`_.
-
-To save you unnecessary boilerplate, ``attrs`` comes with the `attrs.cmp_using` helper to create such functions.
-For NumPy arrays it would look like this::
-
-   import numpy
-
-   @define(order=False)
-   class C:
-      an_array = field(eq=attr.cmp_using(eq=numpy.array_equal))
-
-
-.. warning::
-
-   Please note that *eq* and *order* are set *independently*, because *order* is `False` by default in `attrs.define` (but not in `attr.s`).
-   You can set both at once by using the *cmp* argument that we've undeprecated just for this use-case.

_service:tar_scm:attrs-22.1.0.tar.gz/docs/docutils.conf Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/docs/examples.rst Deleted

@@ -1,712 +0,0 @@
-``attrs`` by Example
-====================
-
-
-Basics
-------
-
-The simplest possible usage is:
-
-.. doctest::
-
-   >>> from attrs import define, field
-   >>> @define
-   ... class Empty:
-   ...     pass
-   >>> Empty()
-   Empty()
-   >>> Empty() == Empty()
-   True
-   >>> Empty() is Empty()
-   False
-
-So in other words: ``attrs`` is useful even without actual attributes!
-
-But you'll usually want some data on your classes, so let's add some:
-
-.. doctest::
-
-   >>> @define
-   ... class Coordinates:
-   ...     x: int
-   ...     y: int
-
-By default, all features are added, so you immediately have a fully functional data class with a nice ``repr`` string and comparison methods.
-
-.. doctest::
-
-   >>> c1 = Coordinates(1, 2)
-   >>> c1
-   Coordinates(x=1, y=2)
-   >>> c2 = Coordinates(x=2, y=1)
-   >>> c2
-   Coordinates(x=2, y=1)
-   >>> c1 == c2
-   False
-
-As shown, the generated ``__init__`` method allows for both positional and keyword arguments.
-
-For private attributes, ``attrs`` will strip the leading underscores for keyword arguments:
-
-.. doctest::
-
-   >>> @define
-   ... class C:
-   ...     _x: int
-   >>> C(x=1)
-   C(_x=1)
-
-If you want to initialize your private attributes yourself, you can do that too:
-
-.. doctest::
-
-   >>> @define
-   ... class C:
-   ...     _x: int = field(init=False, default=42)
-   >>> C()
-   C(_x=42)
-   >>> C(23)
-   Traceback (most recent call last):
-      ...
-   TypeError: __init__() takes exactly 1 argument (2 given)
-
-An additional way of defining attributes is supported too.
-This is useful in times when you want to enhance classes that are not yours (nice ``__repr__`` for Django models anyone?):
-
-.. doctest::
-
-   >>> class SomethingFromSomeoneElse:
-   ...     def __init__(self, x):
-   ...         self.x = x
-   >>> SomethingFromSomeoneElse = define(
-   ...     these={
-   ...         "x": field()
-   ...     }, init=False)(SomethingFromSomeoneElse)
-   >>> SomethingFromSomeoneElse(1)
-   SomethingFromSomeoneElse(x=1)
-
-
-`Subclassing is bad for you <https://www.youtube.com/watch?v=3MNVP9-hglc>`_, but ``attrs`` will still do what you'd hope for:
-
-.. doctest::
-
-   >>> @define(slots=False)
-   ... class A:
-   ...     a: int
-   ...     def get_a(self):
-   ...         return self.a
-   >>> @define(slots=False)
-   ... class B:
-   ...     b: int
-   >>> @define(slots=False)
-   ... class C(B, A):
-   ...     c: int
-   >>> i = C(1, 2, 3)
-   >>> i
-   C(a=1, b=2, c=3)
-   >>> i == C(1, 2, 3)
-   True
-   >>> i.get_a()
-   1
-
-:term:`Slotted classes <slotted classes>`, which are the default for the new APIs, don't play well with multiple inheritance so we don't use them in the example.
-
-The order of the attributes is defined by the `MRO <https://www.python.org/download/releases/2.3/mro/>`_.
-
-Keyword-only Attributes
-~~~~~~~~~~~~~~~~~~~~~~~
-
-You can also add `keyword-only <https://docs.python.org/3/glossary.html#keyword-only-parameter>`_ attributes:
-
-.. doctest::
-
-    >>> @define
-    ... class A:
-    ...     a: int = field(kw_only=True)
-    >>> A()
-    Traceback (most recent call last):
-      ...
-    TypeError: A() missing 1 required keyword-only argument: 'a'
-    >>> A(a=1)
-    A(a=1)
-
-``kw_only`` may also be specified at via ``define``, and will apply to all attributes:
-
-.. doctest::
-
-    >>> @define(kw_only=True)
-    ... class A:
-    ...     a: int
-    ...     b: int
-    >>> A(1, 2)
-    Traceback (most recent call last):
-      ...
-    TypeError: __init__() takes 1 positional argument but 3 were given
-    >>> A(a=1, b=2)
-    A(a=1, b=2)
-
-
-
-If you create an attribute with ``init=False``, the ``kw_only`` argument is ignored.
-
-Keyword-only attributes allow subclasses to add attributes without default values, even if the base class defines attributes with default values:
-
-.. doctest::
-
-    >>> @define
-    ... class A:
-    ...     a: int = 0
-    >>> @define
-    ... class B(A):
-    ...     b: int = field(kw_only=True)
-    >>> B(b=1)
-    B(a=0, b=1)
-    >>> B()
-    Traceback (most recent call last):
-      ...
-    TypeError: B() missing 1 required keyword-only argument: 'b'
-
-If you don't set ``kw_only=True``, then there is no valid attribute ordering, and you'll get an error:
-
-.. doctest::
-
-    >>> @define
-    ... class A:
-    ...     a: int = 0
-    >>> @define
-    ... class B(A):
-    ...     b: int
-    Traceback (most recent call last):
-      ...
-    ValueError: No mandatory attributes allowed after an attribute with a default value or factory.  Attribute in question: Attribute(name='b', default=NOTHING, validator=None, repr=True, cmp=True, hash=None, init=True, converter=None, metadata=mappingproxy({}), type=int, kw_only=False)
-
-.. _asdict:
-
-Converting to Collections Types
--------------------------------
-
-When you have a class with data, it often is very convenient to transform that class into a `dict` (for example if you want to serialize it to JSON):
-
-.. doctest::
-
-   >>> from attrs import asdict
-
-   >>> asdict(Coordinates(x=1, y=2))
-   {'x': 1, 'y': 2}
-
-Some fields cannot or should not be transformed.
-For that, `attrs.asdict` offers a callback that decides whether an attribute should be included:
-

_service:tar_scm:attrs-22.1.0.tar.gz/docs/extending.rst Deleted

@@ -1,313 +0,0 @@
-Extending
-=========
-
-Each ``attrs``-decorated class has a ``__attrs_attrs__`` class attribute.
-It's a tuple of `attrs.Attribute` carrying metadata about each attribute.
-
-So it is fairly simple to build your own decorators on top of ``attrs``:
-
-.. doctest::
-
-   >>> from attr import define
-   >>> def print_attrs(cls):
-   ...     print(cls.__attrs_attrs__)
-   ...     return cls
-   >>> @print_attrs
-   ... @define
-   ... class C:
-   ...     a: int
-   (Attribute(name='a', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'int'>, converter=None, kw_only=False, inherited=False, on_setattr=None),)
-
-
-.. warning::
-
-   The `attrs.define`/`attr.s` decorator **must** be applied first because it puts ``__attrs_attrs__`` in place!
-   That means that is has to come *after* your decorator because::
-
-      @a
-      @b
-      def f():
-         pass
-
-   is just `syntactic sugar <https://en.wikipedia.org/wiki/Syntactic_sugar>`_ for::
-
-      def original_f():
-         pass
-
-      f = a(b(original_f))
-
-
-Wrapping the Decorator
-----------------------
-
-A more elegant way can be to wrap ``attrs`` altogether and build a class `DSL <https://en.wikipedia.org/wiki/Domain-specific_language>`_ on top of it.
-
-An example for that is the package `environ-config <https://github.com/hynek/environ-config>`_ that uses ``attrs`` under the hood to define environment-based configurations declaratively without exposing ``attrs`` APIs at all.
-
-Another common use case is to overwrite ``attrs``'s defaults.
-
-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::
-
-   from mypy.plugin import Plugin
-   from mypy.plugins.attrs import (
-      attr_attrib_makers,
-      attr_class_makers,
-      attr_dataclass_makers,
-   )
-
-   # These work just like `attr.dataclass`.
-   attr_dataclass_makers.add("my_module.method_looks_like_attr_dataclass")
-
-   # This works just like `attr.s`.
-   attr_class_makers.add("my_module.method_looks_like_attr_s")
-
-   # These are our `attr.ib` makers.
-   attr_attrib_makers.add("my_module.method_looks_like_attrib")
-
-   class MyPlugin(Plugin):
-       # Our plugin does nothing but it has to exist so this file gets loaded.
-       pass
-
-
-   def plugin(version):
-       return MyPlugin
-
-
-Then tell mypy about your plugin using your project's ``mypy.ini``:
-
-.. code:: ini
-
-   mypy
-   plugins=<path to file>
-
-
-.. warning::
-   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 <https://github.com/microsoft/pyright>`_ via their dataclass_transform_ specification.
-
-For a custom wrapping of the form::
-
-    def custom_define(f):
-        return attr.define(f)
-
-This is implemented via a ``__dataclass_transform__`` type decorator in the custom extension's ``.pyi`` of the form::
-
-    def __dataclass_transform__(
-        *,
-        eq_default: bool = True,
-        order_default: bool = False,
-        kw_only_default: bool = False,
-        field_descriptors: TupleUniontype, Callable..., Any, ... = (()),
-    ) -> Callable_T, _T: ...
-
-    @__dataclass_transform__(field_descriptors=(attr.attrib, attr.field))
-    def custom_define(f): ...
-
-.. warning::
-
-   ``dataclass_transform`` is supported **provisionally** as of ``pyright`` 1.1.135.
-
-   Both the ``pyright`` dataclass_transform_ specification and ``attrs`` implementation may change in future versions.
-
-
-Types
------
-
-``attrs`` offers two ways of attaching type information to attributes:
-
-- :pep:`526` annotations on Python 3.6 and later,
-- and the *type* argument to `attr.ib`.
-
-This information is available to you:
-
-.. doctest::
-
-   >>> from attr import attrib, define, field, fields
-   >>> @define
-   ... class C:
-   ...     x: int = field()
-   ...     y = attrib(type=str)
-   >>> fields(C).x.type
-   <class 'int'>
-   >>> fields(C).y.type
-   <class 'str'>
-
-Currently, ``attrs`` doesn't do anything with this information but it's very useful if you'd like to write your own validators or serializers!
-
-
-.. _extending_metadata:
-
-Metadata
---------
-
-If you're the author of a third-party library with ``attrs`` integration, you may want to take advantage of attribute metadata.
-
-Here are some tips for effective use of metadata:
-
-- Try making your metadata keys and values immutable.
-  This keeps the entire ``Attribute`` instances immutable too.
-
-- To avoid metadata key collisions, consider exposing your metadata keys from your modules.::
-
-    from mylib import MY_METADATA_KEY
-
-    @define
-    class C:
-      x = field(metadata={MY_METADATA_KEY: 1})
-
-  Metadata should be composable, so consider supporting this approach even if you decide implementing your metadata in one of the following ways.
-
-- Expose ``field`` wrappers for your specific metadata.
-  This is a more graceful approach if your users don't require metadata from other libraries.
-
-  .. doctest::
-
-    >>> from attr import fields, NOTHING
-    >>> MY_TYPE_METADATA = '__my_type_metadata'
-    >>>
-    >>> def typed(
-    ...     cls, default=NOTHING, validator=None, repr=True,
-    ...     eq=True, order=None, hash=None, init=True, metadata=None,
-    ...     converter=None
-    ... ):
-    ...     metadata = metadata or {}
-    ...     metadataMY_TYPE_METADATA = cls
-    ...     return field(
-    ...         default=default, validator=validator, repr=repr,
-    ...         eq=eq, order=order, hash=hash, init=init,
-    ...         metadata=metadata, converter=converter
-    ...     )
-    >>>
-    >>> @define
-    ... class C:
-    ...     x: int = typed(int, default=1, init=False)
-    >>> fields(C).x.metadataMY_TYPE_METADATA
-    <class 'int'>
-
-
-.. _transform-fields:
-
-Automatic Field Transformation and Modification

_service:tar_scm:attrs-22.1.0.tar.gz/docs/glossary.rst Deleted

@@ -1,104 +0,0 @@
-Glossary
-========
-
-.. glossary::
-
-   dunder methods
-      "Dunder" is a contraction of "double underscore".
-
-      It's methods like ``__init__`` or ``__eq__`` that are sometimes also called *magic methods* or it's said that they implement an *object protocol*.
-
-      In spoken form, you'd call ``__init__`` just "dunder init".
-
-      Its first documented use is a `mailing list posting <https://mail.python.org/pipermail/python-list/2002-September/155836.html>`_ by Mark Jackson from 2002.
-
-   dict classes
-      A regular class whose attributes are stored in the `object.__dict__` attribute of every single instance.
-      This is quite wasteful especially for objects with very few data attributes and the space consumption can become significant when creating large numbers of instances.
-
-      This is the type of class you get by default both with and without ``attrs`` (except with the next APIs `attrs.define()`, `attrs.mutable()`, and `attrs.frozen()`).
-
-   slotted classes
-      A class whose instances have no `object.__dict__` attribute and `define <https://docs.python.org/3/reference/datamodel.html#slots>`_ their attributes in a `object.__slots__` attribute instead.
-      In ``attrs``, they are created by passing ``slots=True`` to ``@attr.s`` (and are on by default in `attrs.define()`/`attrs.mutable()`/`attrs.frozen()`).
-
-
-      Their main advantage is that they use less memory on CPython #pypy_ and are slightly faster.
-
-      However they also come with several possibly surprising gotchas:
-
-      - Slotted classes don't allow for any other attribute to be set except for those defined in one of the class' hierarchies ``__slots__``:
-
-        .. doctest::
-
-          >>> from attr import define
-          >>> @define
-          ... class Coordinates:
-          ...     x: int
-          ...     y: int
-          ...
-          >>> c = Coordinates(x=1, y=2)
-          >>> c.z = 3
-          Traceback (most recent call last):
-              ...
-          AttributeError: 'Coordinates' object has no attribute 'z'
-
-      - Slotted classes can inherit from other classes just like non-slotted classes, but some of the benefits of slotted classes are lost if you do that.
-        If you must inherit from other classes, try to inherit only from other slotted classes.
-
-      - However, `it's not possible <https://docs.python.org/3/reference/datamodel.html#notes-on-using-slots>`_ to inherit from more than one class that has attributes in ``__slots__`` (you will get an ``TypeError: multiple bases have instance lay-out conflict``).
-
-      - It's not possible to monkeypatch methods on slotted classes.
-        This can feel limiting in test code, however the need to monkeypatch your own classes is usually a design smell.
-
-        If you really need to monkeypatch an instance in your tests, but don't want to give up on the advantages of slotted classes in production code, you can always subclass a slotted class as a dict class with no further changes and all the limitations go away:
-
-        .. doctest::
-
-           >>> import attr, unittest.mock
-           >>> @define
-           ... class Slotted:
-           ...     x: int
-           ...
-           ...     def method(self):
-           ...         return self.x
-           >>> s = Slotted(42)
-           >>> s.method()
-           42
-           >>> with unittest.mock.patch.object(s, "method", return_value=23):
-           ...     pass
-           Traceback (most recent call last):
-              ...
-           AttributeError: 'Slotted' object attribute 'method' is read-only
-           >>> @define(slots=False)
-           ... class Dicted(Slotted):
-           ...     pass
-           >>> d = Dicted(42)
-           >>> d.method()
-           42
-           >>> with unittest.mock.patch.object(d, "method", return_value=23):
-           ...     assert 23 == d.method()
-
-      - Slotted classes must implement :meth:`__getstate__ <object.__getstate__>` and :meth:`__setstate__ <object.__setstate__>` to be serializable with `pickle` protocol 0 and 1.
-        Therefore, ``attrs`` creates these methods automatically for ``slots=True`` classes.
-
-        .. note::
-
-            If the ``@attr.s(slots=True)`` decorated class already implements the :meth:`__getstate__ <object.__getstate__>` and :meth:`__setstate__ <object.__setstate__>` methods, they will be *overwritten* by ``attrs`` autogenerated implementation by default.
-
-            This can be avoided by setting ``@attr.s(getstate_setstate=False)`` or by setting ``@attr.s(auto_detect=True)``.
-
-        Also, `think twice <https://www.youtube.com/watch?v=7KnfGDajDQw>`_ before using `pickle`.
-
-      - Slotted classes are weak-referenceable by default.
-        This can be disabled in CPython by passing ``weakref_slot=False`` to ``@attr.s`` #pypyweakref_.
-
-      - Since it's currently impossible to make a class slotted after it's been created, ``attrs`` has to replace your class with a new one.
-        While it tries to do that as graciously as possible, certain metaclass features like `object.__init_subclass__` do not work with slotted classes.
-
-      - The `class.__subclasses__` attribute needs a garbage collection run (which can be manually triggered using `gc.collect`), for the original class to be removed.
-        See issue `#407 <https://github.com/python-attrs/attrs/issues/407>`_ for more details.
-
-
-.. #pypy On PyPy, there is no memory advantage in using slotted classes.
-.. #pypyweakref On PyPy, slotted classes are naturally weak-referenceable so ``weakref_slot=False`` has no effect.

_service:tar_scm:attrs-22.1.0.tar.gz/docs/hashing.rst Deleted

@@ -1,86 +0,0 @@
-Hashing
-=======
-
-Hash Method Generation
-----------------------
-
-.. warning::
-
-   The overarching theme is to never set the ``@attr.s(hash=X)`` parameter yourself.
-   Leave it at ``None`` which means that ``attrs`` will do the right thing for you, depending on the other parameters:
-
-   - If you want to make objects hashable by value: use ``@attr.s(frozen=True)``.
-   - If you want hashing and equality by object identity: use ``@attr.s(eq=False)``
-
-   Setting ``hash`` yourself can have unexpected consequences so we recommend to tinker with it only if you know exactly what you're doing.
-
-Under certain circumstances, it's necessary for objects to be *hashable*.
-For example if you want to put them into a `set` or if you want to use them as keys in a `dict`.
-
-The *hash* of an object is an integer that represents the contents of an object.
-It can be obtained by calling `hash` on an object and is implemented by writing a ``__hash__`` method for your class.
-
-``attrs`` will happily write a ``__hash__`` method for you #fn1_, however it will *not* do so by default.
-Because according to the definition_ from the official Python docs, the returned hash has to fulfill certain constraints:
-
-#. Two objects that are equal, **must** have the same hash.
-   This means that if ``x == y``, it *must* follow that ``hash(x) == hash(y)``.
-
-   By default, Python classes are compared *and* hashed by their `id`.
-   That means that every instance of a class has a different hash, no matter what attributes it carries.
-
-   It follows that the moment you (or ``attrs``) change the way equality is handled by implementing ``__eq__`` which is based on attribute values, this constraint is broken.
-   For that reason Python 3 will make a class that has customized equality unhashable.
-   Python 2 on the other hand will happily let you shoot your foot off.
-   Unfortunately, ``attrs`` still mimics (otherwise unsupported) Python 2's behavior for backward compatibility reasons if you set ``hash=False``.
-
-   The *correct way* to achieve hashing by id is to set ``@attr.s(eq=False)``.
-   Setting ``@attr.s(hash=False)`` (which implies ``eq=True``) is almost certainly a *bug*.
-
-   .. warning::
-
-      Be careful when subclassing!
-      Setting ``eq=False`` on a class whose base class has a non-default ``__hash__`` method will *not* make ``attrs`` remove that ``__hash__`` for you.
-
-      It is part of ``attrs``'s philosophy to only *add* to classes so you have the freedom to customize your classes as you wish.
-      So if you want to *get rid* of methods, you'll have to do it by hand.
-
-      The easiest way to reset ``__hash__`` on a class is adding ``__hash__ = object.__hash__`` in the class body.
-
-#. If two objects are not equal, their hash **should** be different.
-
-   While this isn't a requirement from a standpoint of correctness, sets and dicts become less effective if there are a lot of identical hashes.
-   The worst case is when all objects have the same hash which turns a set into a list.
-
-#. The hash of an object **must not** change.
-
-   If you create a class with ``@attr.s(frozen=True)`` this is fulfilled by definition, therefore ``attrs`` will write a ``__hash__`` function for you automatically.
-   You can also force it to write one with ``hash=True`` but then it's *your* responsibility to make sure that the object is not mutated.
-
-   This point is the reason why mutable structures like lists, dictionaries, or sets aren't hashable while immutable ones like tuples or frozensets are:
-   point 1 and 2 require that the hash changes with the contents but point 3 forbids it.
-
-For a more thorough explanation of this topic, please refer to this blog post: `Python Hashes and Equality`_.
-
-
-Hashing and Mutability
-----------------------
-
-Changing any field involved in hash code computation after the first call to ``__hash__`` (typically this would be after its insertion into a hash-based collection) can result in silent bugs.
-Therefore, it is strongly recommended that hashable classes be ``frozen``.
-Beware, however, that this is not a complete guarantee of safety:
-if a field points to an object and that object is mutated, the hash code may change, but ``frozen`` will not protect you.
-
-
-Hash Code Caching
------------------
-
-Some objects have hash codes which are expensive to compute.
-If such objects are to be stored in hash-based collections, it can be useful to compute the hash codes only once and then store the result on the object to make future hash code requests fast.
-To enable caching of hash codes, pass ``cache_hash=True`` to ``@attrs``.
-This may only be done if ``attrs`` is already generating a hash function for the object.
-
-.. #fn1 The hash is computed by hashing a tuple that consists of a unique id for the class plus all attribute values.
-
-.. _definition: https://docs.python.org/3/glossary.html#term-hashable
-.. _`Python Hashes and Equality`: https://hynek.me/articles/hashes-and-equality/

_service:tar_scm:attrs-22.1.0.tar.gz/docs/how-does-it-work.rst Deleted

@@ -1,109 +0,0 @@
-.. _how:
-
-How Does It Work?
-=================
-
-
-Boilerplate
------------
-
-``attrs`` certainly isn't the first library that aims to simplify class definition in Python.
-But its **declarative** approach combined with **no runtime overhead** lets it stand out.
-
-Once you apply the ``@attrs.define`` (or ``@attr.s``) decorator to a class, ``attrs`` searches the class object for instances of ``attr.ib``\ s.
-Internally they're a representation of the data passed into ``attr.ib`` along with a counter to preserve the order of the attributes.
-Alternatively, it's possible to define them using :doc:`types`.
-
-In order to ensure that subclassing works as you'd expect it to work, ``attrs`` also walks the class hierarchy and collects the attributes of all base classes.
-Please note that ``attrs`` does *not* call ``super()`` *ever*.
-It will write :term:`dunder methods` to work on *all* of those attributes which also has performance benefits due to fewer function calls.
-
-Once ``attrs`` knows what attributes it has to work on, it writes the requested :term:`dunder methods` and -- depending on whether you wish to have a :term:`dict <dict classes>` or :term:`slotted <slotted classes>` class -- creates a new class for you (``slots=True``) or attaches them to the original class (``slots=False``).
-While creating new classes is more elegant, we've run into several edge cases surrounding metaclasses that make it impossible to go this route unconditionally.
-
-To be very clear: if you define a class with a single attribute without a default value, the generated ``__init__`` will look *exactly* how you'd expect:
-
-.. doctest::
-
-   >>> import inspect
-   >>> from attr import define
-   >>> @define
-   ... class C:
-   ...     x: int
-   >>> print(inspect.getsource(C.__init__))
-   def __init__(self, x):
-       self.x = x
-   <BLANKLINE>
-
-No magic, no meta programming, no expensive introspection at runtime.
-
-****
-
-Everything until this point happens exactly *once* when the class is defined.
-As soon as a class is done, it's done.
-And it's just a regular Python class like any other, except for a single ``__attrs_attrs__`` attribute that ``attrs`` uses internally.
-Much of the information is accessible via `attrs.fields` and other functions which can be used for introspection or for writing your own tools and decorators on top of ``attrs`` (like `attrs.asdict`).
-
-And once you start instantiating your classes, ``attrs`` is out of your way completely.
-
-This **static** approach was very much a design goal of ``attrs`` and what I strongly believe makes it distinct.
-
-
-.. _how-frozen:
-
-Immutability
-------------
-
-In order to give you immutability, ``attrs`` will attach a ``__setattr__`` method to your class that raises an `attrs.exceptions.FrozenInstanceError` whenever anyone tries to set an attribute.
-
-The same is true if you choose to freeze individual attributes using the `attrs.setters.frozen` *on_setattr* hook -- except that the exception becomes `attrs.exceptions.FrozenAttributeError`.
-
-Both errors subclass `attrs.exceptions.FrozenError`.
-
------
-
-Depending on whether a class is a dict class or a slotted class, ``attrs`` uses a different technique to circumvent that limitation in the ``__init__`` method.
-
-Once constructed, frozen instances don't differ in any way from regular ones except that you cannot change its attributes.
-
-
-Dict Classes
-++++++++++++
-
-Dict classes -- i.e. regular classes -- simply assign the value directly into the class' eponymous ``__dict__`` (and there's nothing we can do to stop the user to do the same).
-
-The performance impact is negligible.
-
-
-Slotted Classes
-+++++++++++++++
-
-Slotted classes are more complicated.
-Here it uses (an aggressively cached) :meth:`object.__setattr__` to set your attributes.
-This is (still) slower than a plain assignment:
-
-.. code-block:: none
-
-  $ pyperf timeit --rigorous \
-        -s "import attr; C = attr.make_class('C', 'x', 'y', 'z', slots=True)" \
-        "C(1, 2, 3)"
-  .........................................
-  Mean +- std dev: 228 ns +- 18 ns
-
-  $ pyperf timeit --rigorous \
-        -s "import attr; C = attr.make_class('C', 'x', 'y', 'z', slots=True, frozen=True)" \
-        "C(1, 2, 3)"
-  .........................................
-  Mean +- std dev: 450 ns +- 26 ns
-
-So on a laptop computer the difference is about 230 nanoseconds (1 second is 1,000,000,000 nanoseconds).
-It's certainly something you'll feel in a hot loop but shouldn't matter in normal code.
-Pick what's more important to you.
-
-
-Summary
-+++++++
-
-You should avoid instantiating lots of frozen slotted classes (i.e. ``@frozen``) in performance-critical code.
-
-Frozen dict classes have barely a performance impact, unfrozen slotted classes are even *faster* than unfrozen dict classes (i.e. regular classes).

_service:tar_scm:attrs-22.1.0.tar.gz/docs/index.rst Deleted

@@ -1,88 +0,0 @@
-.. module:: attr
-.. module:: attrs
-
-======================================
-``attrs``: Classes Without Boilerplate
-======================================
-
-Release v\ |release| (`What's new? <changelog>`).
-
-.. include:: ../README.rst
-   :start-after: teaser-begin
-   :end-before: teaser-end
-
-
-Getting Started
-===============
-
-``attrs`` is a Python-only package `hosted on PyPI <https://pypi.org/project/attrs/>`_.
-The recommended installation method is `pip <https://pip.pypa.io/en/stable/>`_-installing into a `virtualenv <https://hynek.me/articles/virtualenv-lives/>`_:
-
-.. code-block:: console
-
-   $ python -m pip install attrs
-
-The next steps will get you up and running in no time:
-
-- `overview` will show you a simple example of ``attrs`` in action and introduce you to its philosophy.
-  Afterwards, you can start writing your own classes and understand what drives ``attrs``'s design.
-- `examples` will give you a comprehensive tour of ``attrs``'s features.
-  After reading, you will know about our advanced features and how to use them.
-- `why` gives you a rundown of potential alternatives and why we think ``attrs`` is still worthwhile -- depending on *your* needs even superior.
-- If at any point you get confused by some terminology, please check out our `glossary`.
-
-
-If you need any help while getting started, feel free to use the ``python-attrs`` tag on `Stack Overflow <https://stackoverflow.com/questions/tagged/python-attrs>`_ and someone will surely help you out!
-
-
-Day-to-Day Usage
-================
-
-- `types` help you to write *correct* and *self-documenting* code.
-  ``attrs`` has first class support for them, yet keeps them optional if you’re not convinced!
-- Instance initialization is one of ``attrs`` key feature areas.
-  Our goal is to relieve you from writing as much code as possible.
-  `init` gives you an overview what ``attrs`` has to offer and explains some related philosophies we believe in.
-- Comparing and ordering objects is a common task.
-  `comparison` shows you how ``attrs`` helps you with that and how you can customize it.
-- If you want to put objects into sets or use them as keys in dictionaries, they have to be hashable.
-  The simplest way to do that is to use frozen classes, but the topic is more complex than it seems and `hashing` will give you a primer on what to look out for.
-- Once you're comfortable with the concepts, our `api` contains all information you need to use ``attrs`` to its fullest.
-- ``attrs`` is built for extension from the ground up.
-  `extending` will show you the affordances it offers and how to make it a building block of your own projects.
-- Finally, if you're confused by all the ``attr.s``, ``attr.ib``, ``attrs``, ``attrib``, ``define``, ``frozen``, and ``field``, head over to `names` for a very short explanation, and optionally a quick history lesson.
-
-
-.. include:: ../README.rst
-   :start-after: -project-information-
-
-----
-
-
-Full Table of Contents
-======================
-
-.. toctree::
-   :maxdepth: 2
-
-   overview
-   why
-   examples
-   types
-   init
-   comparison
-   hashing
-   api
-   extending
-   how-does-it-work
-   names
-   glossary
-
-.. toctree::
-   :maxdepth: 1
-
-   license
-   changelog
-
-
-`Full Index <genindex>`

_service:tar_scm:attrs-22.1.0.tar.gz/docs/init.rst Deleted

@@ -1,490 +0,0 @@
-Initialization
-==============
-
-In Python, instance initialization happens in the ``__init__`` method.
-Generally speaking, you should keep as little logic as possible in it, and you should think about what the class needs and not how it is going to be instantiated.
-
-Passing complex objects into ``__init__`` and then using them to derive data for the class unnecessarily couples your new class with the old class which makes it harder to test and also will cause problems later.
-
-So assuming you use an ORM and want to extract 2D points from a row object, do not write code like this::
-
-    class Point:
-        def __init__(self, database_row):
-            self.x = database_row.x
-            self.y = database_row.y
-
-    pt = Point(row)
-
-Instead, write a `classmethod` that will extract it for you::
-
-   @define
-   class Point:
-       x: float
-       y: float
-
-       @classmethod
-       def from_row(cls, row):
-           return cls(row.x, row.y)
-
-   pt = Point.from_row(row)
-
-Now you can instantiate ``Point``\ s without creating fake row objects in your tests and you can have as many smart creation helpers as you want, in case more data sources appear.
-
-For similar reasons, we strongly discourage from patterns like::
-
-   pt = Point(**row.attributes)
-
-which couples your classes to the database data model.
-Try to design your classes in a way that is clean and convenient to use -- not based on your database format.
-The database format can change anytime and you're stuck with a bad class design that is hard to change.
-Embrace functions and classmethods as a filter between reality and what's best for you to work with.
-
-If you look for object serialization, there's a bunch of projects listed on our ``attrs`` extensions `Wiki page`_.
-Some of them even support nested schemas.
-
-
-Private Attributes
-------------------
-
-One thing people tend to find confusing is the treatment of private attributes that start with an underscore.
-``attrs`` follows the doctrine that `there is no such thing as a private argument`_ and strips the underscores from the name when writing the ``__init__`` method signature:
-
-.. doctest::
-
-   >>> import inspect, attr, attrs
-   >>> from attr import define
-   >>> @define
-   ... class C:
-   ...    _x: int
-   >>> inspect.signature(C.__init__)
-   <Signature (self, x: int) -> None>
-
-There really isn't a right or wrong, it's a matter of taste.
-But it's important to be aware of it because it can lead to surprising syntax errors:
-
-.. doctest::
-
-   >>> @define
-   ... class C:
-   ...    _1: int
-   Traceback (most recent call last):
-      ...
-   SyntaxError: invalid syntax
-
-In this case a valid attribute name ``_1`` got transformed into an invalid argument name ``1``.
-
-
-Defaults
---------
-
-Sometimes you don't want to pass all attribute values to a class.
-And sometimes, certain attributes aren't even intended to be passed but you want to allow for customization anyways for easier testing.
-
-This is when default values come into play:
-
-.. doctest::
-
-   >>> from attr import define, field, Factory
-
-   >>> @define
-   ... class C:
-   ...     a: int = 42
-   ...     b: list = field(factory=list)
-   ...     c: list = Factory(list)  # syntactic sugar for above
-   ...     d: dict = field()
-   ...     @d.default
-   ...     def _any_name_except_a_name_of_an_attribute(self):
-   ...        return {}
-   >>> C()
-   C(a=42, b=, c=, d={})
-
-It's important that the decorated method -- or any other method or property! -- doesn't have the same name as the attribute, otherwise it would overwrite the attribute definition.
-
-Please note that as with function and method signatures, ``default=`` will *not* do what you may think it might do:
-
-.. doctest::
-
-   >>> @define
-   ... class C:
-   ...     x = 
-   >>> i = C()
-   >>> k = C()
-   >>> i.x.append(42)
-   >>> k.x
-   42
-
-
-This is why ``attrs`` comes with factory options.
-
-.. warning::
-
-   Please note that the decorator based defaults have one gotcha:
-   they are executed when the attribute is set, that means depending on the order of attributes, the ``self`` object may not be fully initialized when they're called.
-
-   Therefore you should use ``self`` as little as possible.
-
-   Even the smartest of us can `get confused`_ by what happens if you pass partially initialized objects around.
-
-
-.. _validators:
-
-Validators
-----------
-
-Another thing that definitely *does* belong in ``__init__`` is checking the resulting instance for invariants.
-This is why ``attrs`` has the concept of validators.
-
-
-Decorator
-~~~~~~~~~
-
-The most straightforward way is using the attribute's ``validator`` method as a decorator.
-
-The method has to accept three arguments:
-
-#. the *instance* that's being validated (aka ``self``),
-#. the *attribute* that it's validating, and finally
-#. the *value* that is passed for it.
-
-These values are passed as *positional arguments*, therefore their names don't matter.
-
-If the value does not pass the validator's standards, it just raises an appropriate exception.
-
-   >>> @define
-   ... class C:
-   ...     x: int = field()
-   ...     @x.validator
-   ...     def _check_x(self, attribute, value):
-   ...         if value > 42:
-   ...             raise ValueError("x must be smaller or equal to 42")
-   >>> C(42)
-   C(x=42)
-   >>> C(43)
-   Traceback (most recent call last):
-      ...
-   ValueError: x must be smaller or equal to 42
-
-Again, it's important that the decorated method doesn't have the same name as the attribute and that the `attrs.field()` helper is used.
-
-
-Callables
-~~~~~~~~~
-
-If you want to re-use your validators, you should have a look at the ``validator`` argument to `attrs.field`.
-
-It takes either a callable or a list of callables (usually functions) and treats them as validators that receive the same arguments as with the decorator approach.
-Also as with the decorator approach, they are passed as *positional arguments* so you can name them however you want.
-
-Since the validators run *after* the instance is initialized, you can refer to other attributes while validating:
-
-.. doctest::
-
-   >>> def x_smaller_than_y(instance, attribute, value):
-   ...     if value >= instance.y:
-   ...         raise ValueError("'x' has to be smaller than 'y'!")
-   >>> @define
-   ... class C:
-   ...     x = field(validator=attrs.validators.instance_of(int),
-   ...                          x_smaller_than_y)
-   ...     y = field()
-   >>> C(x=3, y=4)
-   C(x=3, y=4)
-   >>> C(x=4, y=3)
-   Traceback (most recent call last):
-      ...
-   ValueError: 'x' has to be smaller than 'y'!
-
-This example also shows of some syntactic sugar for using the `attrs.validators.and_` validator: if you pass a list, all validators have to pass.
-
-``attrs`` won't intercept your changes to those attributes but you can always call `attrs.validate` on any instance to verify that it's still valid:

_service:tar_scm:attrs-22.1.0.tar.gz/docs/license.rst Deleted

_service:tar_scm:attrs-22.1.0.tar.gz/docs/names.rst Deleted

@@ -1,122 +0,0 @@
-On The Core API Names
-=====================
-
-You may be surprised seeing ``attrs`` classes being created using `attrs.define` and with type annotated fields, instead of `attr.s` and `attr.ib()`.
-
-Or, you wonder why the web and talks are full of this weird `attr.s` and `attr.ib` -- including people having strong opinions about it and using ``attr.attrs`` and ``attr.attrib`` instead.
-
-And what even is ``attr.dataclass`` that's not documented but commonly used!?
-
-
-TL;DR
------
-
-We recommend our modern APIs for new code:
-
-- `attrs.define()` to define a new class,
-- `attrs.mutable()` is an alias for `attrs.define()`,
-- `attrs.frozen()` is an alias for ``define(frozen=True)``
-- and `attrs.field()` to define an attribute.
-
-They have been added in ``attrs`` 20.1.0, they are expressive, and they have modern defaults like slots and type annotation awareness switched on by default.
-They are only available in Python 3.6 and later.
-Sometimes they're referred to as *next-generation* or *NG* APIs.
-As of ``attrs`` 21.3.0 you can also import them from the ``attrs`` package namespace.
-
-The traditional APIs `attr.s` / `attr.ib`, their serious-business aliases ``attr.attrs`` / ``attr.attrib``, and the never-documented, but popular ``attr.dataclass`` easter egg will stay **forever**.
-
-``attrs`` will **never** force you to use type annotations.
-
-
-A Short History Lesson
-----------------------
-
-At this point, ``attrs`` is an old project.
-It had its first release in April 2015 -- back when most Python code was on Python 2.7 and Python 3.4 was the first Python 3 release that showed promise.
-``attrs`` was always Python 3-first, but `type annotations <https://peps.python.org/pep-0484/>`_ came only into Python 3.5 that was released in September 2015 and were largely ignored until years later.
-
-At this time, if you didn't want to implement all the :term:`dunder methods`, the most common way to create a class with some attributes on it was to subclass a `collections.namedtuple`, or one of the many hacks that allowed you to access dictionary keys using attribute lookup.
-
-But ``attrs`` history goes even a bit further back, to the now-forgotten `characteristic <https://github.com/hynek/characteristic>`_ that came out in May 2014 and already used a class decorator, but was overall too unergonomic.
-
-In the wake of all of that, `glyph <https://twitter.com/glyph>`_ and `Hynek <https://twitter.com/hynek>`_ came together on IRC and brainstormed how to take the good ideas of ``characteristic``, but make them easier to use and read.
-At this point the plan was not to make ``attrs`` what it is now -- a flexible class building kit.
-All we wanted was an ergonomic little library to succinctly define classes with attributes.
-
-Under the impression of the unwieldy ``characteristic`` name, we went to the other side and decided to make the package name part of the API, and keep the API functions very short.
-This led to the infamous `attr.s` and `attr.ib` which some found confusing and pronounced it as "attr dot s" or used a singular ``@s`` as the decorator.
-But it was really just a way to say ``attrs`` and ``attrib``\ #attr_.
-
-Some people hated this cutey API from day one, which is why we added aliases for them that we called *serious business*: ``@attr.attrs`` and ``attr.attrib()``.
-Fans of them usually imported the names and didn't use the package name in the first place.
-Unfortunately, the ``attr`` package name started creaking the moment we added ``attr.Factory``, since it couldn’t be morphed into something meaningful in any way.
-A problem that grew worse over time, as more APIs and even modules were added.
-
-But overall, ``attrs`` in this shape was a **huge** success -- especially after glyph's blog post `The One Python Library Everyone Needs <https://glyph.twistedmatrix.com/2016/08/attrs.html>`_ in August 2016 and `pytest <https://docs.pytest.org/>`_ adopting it.
-
-Being able to just write::
-
-   @attr.s
-   class Point:
-       x = attr.ib()
-       y = attr.ib()
-
-was a big step for those who wanted to write small, focused classes.
-
-
-Dataclasses Enter The Arena
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-A big change happened in May 2017 when Hynek sat down with `Guido van Rossum <https://en.wikipedia.org/wiki/Guido_van_Rossum>`_ and `Eric V. Smith <https://github.com/ericvsmith>`_ at PyCon US 2017.
-
-Type annotations for class attributes have `just landed <https://peps.python.org/pep-0526/>`_ in Python 3.6 and Guido felt like it would be a good mechanic to introduce something similar to ``attrs`` to the Python standard library.
-The result, of course, was :pep:`557`\ #stdlib_ which eventually became the `dataclasses` module in Python 3.7.
-
-``attrs`` at this point was lucky to have several people on board who were also very excited about type annotations and helped implement it; including a `Mypy plugin <https://medium.com/@Pilot-EPD-Blog/mypy-and-attrs-e1b0225e9ac6>`_.
-And so it happened that ``attrs`` `shipped <https://www.attrs.org/en/17.3.0.post2/changelog.html>`_ the new method of defining classes more than half a year before Python 3.7 -- and thus `dataclasses` -- were released.
-
------
-
-Due to backward-compatibility concerns, this feature is off by default in the `attr.s` decorator and has to be activated using ``@attr.s(auto_attribs=True)``, though.
-As a little easter egg and to save ourselves some typing, we've also `added <https://github.com/python-attrs/attrs/commit/88aa1c897dfe2ee4aa987e4a56f2ba1344a17238#diff-4fc63db1f2fcb7c6e464ee9a77c3c74e90dd191d1c9ffc3bdd1234d3a6663dc0R48>`_ an alias called ``attr.dataclasses`` that just set ``auto_attribs=True``.
-It was never documented, but people found it and used it and loved it.
-
-Over the next months and years it became clear that type annotations have become the popular way to define classes and their attributes.
-However, it has also become clear that some people viscerally hate type annotations.
-We're determined to serve both.
-
-
-``attrs`` TNG
-^^^^^^^^^^^^^
-
-Over its existence, ``attrs`` never stood still.
-But since we also greatly care about backward compatibility and not breaking our users' code, many features and niceties have to be manually activated.
-
-That is not only annoying, it also leads to the problem that many of ``attrs``'s users don't even know what it can do for them.
-We've spent years alone explaining that defining attributes using type annotations is in no way unique to `dataclasses`.
-
-Finally we've decided to take the `Go route <https://go.dev/blog/module-compatibility>`_:
-instead of fiddling with the old APIs -- whose names felt anachronistic anyway -- we'd define new ones, with better defaults.
-So in July 2018, we `looked for better names <https://github.com/python-attrs/attrs/issues/408>`_ and came up with `attr.define`, `attr.field`, and friends.
-Then in January 2019, we `started looking for inconvenient defaults <https://github.com/python-attrs/attrs/issues/487>`_ that we now could fix without any repercussions.
-
-These APIs proved to be very popular, so we've finally changed the documentation to them in November of 2021.
-
-All of this took way too long, of course.
-One reason is the COVID-19 pandemic, but also our fear to fumble this historic chance to fix our APIs.
-
-Finally, in December 2021, we've added the ``attrs`` package namespace.
-
-We hope you like the result::
-
-   from attrs import define
-
-   @define
-   class Point:
-       x: int
-       y: int
-
-
-.. #attr We considered calling the PyPI package just ``attr`` too, but the name was already taken by an *ostensibly* inactive `package on PyPI <https://pypi.org/project/attr/#history>`_.
-.. #stdlib The highly readable PEP also explains why ``attrs`` wasn't just added to the standard library.
-   Don't believe the myths and rumors.

_service:tar_scm:attrs-22.1.0.tar.gz/docs/overview.rst Deleted

@@ -1,58 +0,0 @@
-========
-Overview
-========
-
-In order to fulfill its ambitious goal of bringing back the joy to writing classes, it gives you a class decorator and a way to declaratively define the attributes on that class:
-
-.. include:: ../README.rst
-   :start-after: -code-begin-
-   :end-before: -project-information-
-
-
-.. _philosophy:
-
-Philosophy
-==========
-
-**It's about regular classes.**
-   ``attrs`` is for creating well-behaved classes with a type, attributes, methods, and everything that comes with a class.
-   It can be used for data-only containers like ``namedtuple``\ s or ``types.SimpleNamespace`` but they're just a sub-genre of what ``attrs`` is good for.
-
-**The class belongs to the users.**
-   You define a class and ``attrs`` adds static methods to that class based on the attributes you declare.
-   The end.
-   It doesn't add metaclasses.
-   It doesn't add classes you've never heard of to your inheritance tree.
-   An ``attrs`` class in runtime is indistinguishable from a regular class: because it *is* a regular class with a few boilerplate-y methods attached.
-
-**Be light on API impact.**
-   As convenient as it seems at first, ``attrs`` will *not* tack on any methods to your classes except for the :term:`dunder ones <dunder methods>`.
-   Hence all the useful `tools <helpers>` that come with ``attrs`` live in functions that operate on top of instances.
-   Since they take an ``attrs`` instance as their first argument, you can attach them to your classes with one line of code.
-
-**Performance matters.**
-   ``attrs`` runtime impact is very close to zero because all the work is done when the class is defined.
-   Once you're instantiating it, ``attrs`` is out of the picture completely.
-
-**No surprises.**
-   ``attrs`` creates classes that arguably work the way a Python beginner would reasonably expect them to work.
-   It doesn't try to guess what you mean because explicit is better than implicit.
-   It doesn't try to be clever because software shouldn't be clever.
-
-Check out `how-does-it-work` if you'd like to know how it achieves all of the above.
-
-
-What ``attrs`` Is Not
-=====================
-
-``attrs`` does *not* invent some kind of magic system that pulls classes out of its hat using meta classes, runtime introspection, and shaky interdependencies.
-
-All ``attrs`` does is:
-
-1. Take your declaration,
-2. write :term:`dunder methods` based on that information,
-3. and attach them to your class.
-
-It does *nothing* dynamic at runtime, hence zero runtime overhead.
-It's still *your* class.
-Do with it as you please.

_service:tar_scm:attrs-22.1.0.tar.gz/docs/types.rst Deleted

@@ -1,108 +0,0 @@
-Type Annotations
-================
-
-``attrs`` comes with first class support for type annotations for both Python 3.6 (:pep:`526`) and legacy syntax.
-
-However they will forever remain *optional*, therefore the example from the README could also be written as:
-
-.. doctest::
-
-   >>> from attrs import define, field
-
-   >>> @define
-   ... class SomeClass:
-   ...     a_number = field(default=42)
-   ...     list_of_numbers = field(factory=list)
-
-   >>> sc = SomeClass(1, 1, 2, 3)
-   >>> sc
-   SomeClass(a_number=1, list_of_numbers=1, 2, 3)
-
-You can choose freely between the approaches, but please remember that if you choose to use type annotations, you **must** annotate **all** attributes!
-
-----
-
-Even when going all-in on type annotations, you will need `attr.field` for some advanced features though.
-
-One of those features are the decorator-based features like defaults.
-It's important to remember that ``attrs`` doesn't do any magic behind your back.
-All the decorators are implemented using an object that is returned by the call to `attrs.field`.
-
-Attributes that only carry a class annotation do not have that object so trying to call a method on it will inevitably fail.
-
-*****
-
-Please note that types -- however added -- are *only metadata* that can be queried from the class and they aren't used for anything out of the box!
-
-Because Python does not allow references to a class object before the class is defined,
-types may be defined as string literals, so-called *forward references* (:pep:`526`).
-You can enable this automatically for a whole module by using ``from __future__ import annotations`` (:pep:`563`) as of Python 3.7.
-In this case ``attrs`` simply puts these string literals into the ``type`` attributes.
-If you need to resolve these to real types, you can call `attrs.resolve_types` which will update the attribute in place.
-
-In practice though, types show their biggest usefulness in combination with tools like mypy_, pytype_, or pyright_ 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 write *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
-----
-
-While having a nice syntax for type metadata is great, it's even greater that mypy_ as of 0.570 ships with a dedicated ``attrs`` plugin which allows you to statically check your code.
-
-Imagine you add another line that tries to instantiate the defined class using ``SomeClass("23")``.
-Mypy will catch that error for you:
-
-.. code-block:: console
-
-   $ mypy t.py
-   t.py:12: error: Argument 1 to "SomeClass" has incompatible type "str"; expected "int"
-
-This happens *without* running your code!
-
-And it also works with *both* Python 2-style annotation styles.
-To mypy, this code is equivalent to the one above:
-
-.. code-block:: python
-
-  @attr.s
-  class SomeClass:
-      a_number = attr.ib(default=42)  # type: int
-      list_of_numbers = attr.ib(factory=list, type=listint)
-
-
-pyright
--------
-
-``attrs`` provides support for pyright_ though the dataclass_transform_ specification.
-This provides static type inference for a subset of ``attrs`` equivalent to standard-library ``dataclasses``,
-and requires explicit type annotations using the `attrs.define` 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::
-
-  @attr.define
-  class SomeClass:
-      a_number: int = 42
-      list_of_numbers: listint = attr.field(factory=list)
-
-.. warning::
-
-   The ``pyright`` inferred types are a subset of those supported by ``mypy``, including:
-
-   - The generated ``__init__`` signature only includes the attribute type annotations.
-     It currently 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)``.
-
-     A `full list <https://github.com/microsoft/pyright/blob/main/specs/dataclass_transforms.md#attrs>`_ of limitations and incompatibilities can be found in pyright's repository.
-
-   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>`_.
-   Generally speaking, the decision on improving ``attrs`` support in pyright is entirely Microsoft's prerogative though.
-
-
-.. _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/main/specs/dataclass_transforms.md

_service:tar_scm:attrs-22.1.0.tar.gz/docs/why.rst Deleted

@@ -1,290 +0,0 @@
-Why not…
-========
-
-
-If you'd like third party's account why ``attrs`` is great, have a look at Glyph's `The One Python Library Everyone Needs <https://glyph.twistedmatrix.com/2016/08/attrs.html>`_. It predates type annotations and hence Data Classes, but it masterfully illustrates the appeal of class-building packages.
-
-
-…Data Classes?
---------------
-
-:pep:`557` added Data Classes to `Python 3.7 <https://docs.python.org/3.7/whatsnew/3.7.html#dataclasses>`_ that resemble ``attrs`` in many ways.
-
-They are the result of the Python community's `wish <https://mail.python.org/pipermail/python-ideas/2017-May/045618.html>`_ to have an easier way to write classes in the standard library that doesn't carry the problems of ``namedtuple``\ s.
-To that end, ``attrs`` and its developers were involved in the PEP process and while we may disagree with some minor decisions that have been made, it's a fine library and if it stops you from abusing ``namedtuple``\ s, they are a huge win.
-
-Nevertheless, there are still reasons to prefer ``attrs`` over Data Classes.
-Whether they're relevant to *you* depends on your circumstances:
-
-- Data Classes are *intentionally* less powerful than ``attrs``.
-  There is a long list of features that were sacrificed for the sake of simplicity and while the most obvious ones are validators, converters, :ref:`equality customization <custom-comparison>`, or :doc:`extensibility <extending>` in general, it permeates throughout all APIs.
-
-  On the other hand, Data Classes currently do not offer any significant feature that ``attrs`` doesn't already have.
-- ``attrs`` supports all mainstream Python versions including PyPy.
-- ``attrs`` doesn't force type annotations on you if you don't like them.
-- But since it **also** supports typing, it's the best way to embrace type hints *gradually*, too.
-- While Data Classes are implementing features from ``attrs`` every now and then, their presence is dependent on the Python version, not the package version.
-  For example, support for ``__slots__`` has only been added in Python 3.10, but it doesn’t do cell rewriting and therefore doesn’t support bare calls to ``super()``.
-  This may or may not be fixed in later Python releases, but handling all these differences is especially painful for PyPI packages that support multiple Python versions.
-  And of course, this includes possible implementation bugs.
-- ``attrs`` can and will move faster.
-  We are not bound to any release schedules and we have a clear deprecation policy.
-
-  One of the `reasons <https://peps.python.org/pep-0557/#why-not-just-use-attrs>`_ to not vendor ``attrs`` in the standard library was to not impede ``attrs``'s future development.
-
-One way to think about ``attrs`` vs Data Classes is that ``attrs`` is a fully-fledged toolkit to write powerful classes while Data Classes are an easy way to get a class with some attributes.
-Basically what ``attrs`` was in 2015.
-
-
-…pydantic?
-----------
-
-*pydantic* is first and foremost a *data validation library*.
-As such, it is a capable complement to class building libraries like ``attrs`` (or Data Classes!) for parsing and validating untrusted data.
-
-However, as convenient as it might be, using it for your business or data layer `is problematic in several ways <https://threeofwands.com/why-i-use-attrs-instead-of-pydantic/>`_:
-Is it really necessary to re-validate all your objects while reading them from a trusted database?
-In the parlance of `Form, Command, and Model Validation <https://verraes.net/2015/02/form-command-model-validation/>`_, *pydantic* is the right tool for *Commands*.
-
-`Separation of concerns <https://en.wikipedia.org/wiki/Separation_of_concerns>`_ feels tedious at times, but it's one of those things that you get to appreciate once you've shot your own foot often enough.
-
-
-…namedtuples?
--------------
-
-`collections.namedtuple`\ s are tuples with names, not classes. #history_
-Since writing classes is tiresome in Python, every now and then someone discovers all the typing they could save and gets really excited.
-However, that convenience comes at a price.
-
-The most obvious difference between ``namedtuple``\ s and ``attrs``-based classes is that the latter are type-sensitive:
-
-.. doctest::
-
-   >>> import attr
-   >>> C1 = attr.make_class("C1", "a")
-   >>> C2 = attr.make_class("C2", "a")
-   >>> i1 = C1(1)
-   >>> i2 = C2(1)
-   >>> i1.a == i2.a
-   True
-   >>> i1 == i2
-   False
-
-…while a ``namedtuple`` is *intentionally* `behaving like a tuple`_ which means the type of a tuple is *ignored*:
-
-.. doctest::
-
-   >>> from collections import namedtuple
-   >>> NT1 = namedtuple("NT1", "a")
-   >>> NT2 = namedtuple("NT2", "b")
-   >>> t1 = NT1(1)
-   >>> t2 = NT2(1)
-   >>> t1 == t2 == (1,)
-   True
-
-Other often surprising behaviors include:
-
-- Since they are a subclass of tuples, ``namedtuple``\ s have a length and are both iterable and indexable.
-  That's not what you'd expect from a class and is likely to shadow subtle typo bugs.
-- Iterability also implies that it's easy to accidentally unpack a ``namedtuple`` which leads to hard-to-find bugs. #iter_
-- ``namedtuple``\ s have their methods *on your instances* whether you like it or not. #pollution_
-- ``namedtuple``\ s are *always* immutable.
-  Not only does that mean that you can't decide for yourself whether your instances should be immutable or not, it also means that if you want to influence your class' initialization (validation? default values?), you have to implement :meth:`__new__() <object.__new__>` which is a particularly hacky and error-prone requirement for a very common problem. #immutable_
-- To attach methods to a ``namedtuple`` you have to subclass it.
-  And if you follow the standard library documentation's recommendation of::
-
-    class Point(namedtuple('Point', 'x', 'y')):
-        # ...
-
-  you end up with a class that has *two* ``Point``\ s in its :attr:`__mro__ <class.__mro__>`: ``<class 'point.Point'>, <class 'point.Point'>, <type 'tuple'>, <type 'object'>``.
-
-  That's not only confusing, it also has very practical consequences:
-  for example if you create documentation that includes class hierarchies like `Sphinx's autodoc <https://www.sphinx-doc.org/en/stable/usage/extensions/autodoc.html>`_ with ``show-inheritance``.
-  Again: common problem, hacky solution with confusing fallout.
-
-All these things make ``namedtuple``\ s a particularly poor choice for public APIs because all your objects are irrevocably tainted.
-With ``attrs`` your users won't notice a difference because it creates regular, well-behaved classes.
-
-.. admonition:: Summary
-
-  If you want a *tuple with names*, by all means: go for a ``namedtuple``. #perf_
-  But if you want a class with methods, you're doing yourself a disservice by relying on a pile of hacks that requires you to employ even more hacks as your requirements expand.
-
-  Other than that, ``attrs`` also adds nifty features like validators, converters, and (mutable!) default values.
-
-
-.. rubric:: Footnotes
-
-.. #history The word is that ``namedtuple``\ s were added to the Python standard library as a way to make tuples in return values more readable.
-              And indeed that is something you see throughout the standard library.
-
-              Looking at what the makers of ``namedtuple``\ s use it for themselves is a good guideline for deciding on your own use cases.
-.. #pollution ``attrs`` only adds a single attribute: ``__attrs_attrs__`` for introspection.
-                All helpers are functions in the ``attr`` package.
-                Since they take the instance as first argument, you can easily attach them to your classes under a name of your own choice.
-.. #iter `attr.astuple` can be used to get that behavior in ``attrs`` on *explicit demand*.
-.. #immutable ``attrs`` offers *optional* immutability through the ``frozen`` keyword.
-.. #perf Although ``attrs`` would serve you just as well!
-           Since both employ the same method of writing and compiling Python code for you, the performance penalty is negligible at worst and in some cases ``attrs`` is even faster if you use ``slots=True`` (which is generally a good idea anyway).
-
-.. _behaving like a tuple: https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences
-
-
-…tuples?
---------
-
-Readability
-^^^^^^^^^^^
-
-What makes more sense while debugging::
-
-   Point(x=1, y=2)
-
-or::
-
-   (1, 2)
-
-?
-
-Let's add even more ambiguity::
-
-   Customer(id=42, reseller=23, first_name="Jane", last_name="John")
-
-or::
-
-   (42, 23, "Jane", "John")
-
-?
-
-Why would you want to write ``customer2`` instead of ``customer.first_name``?
-
-Don't get me started when you add nesting.
-If you've never run into mysterious tuples you had no idea what the hell they meant while debugging, you're much smarter than yours truly.
-
-Using proper classes with names and types makes program code much more readable and comprehensible_.
-Especially when trying to grok a new piece of software or returning to old code after several months.
-
-.. _comprehensible: https://arxiv.org/pdf/1304.5257.pdf
-
-
-Extendability
-^^^^^^^^^^^^^
-
-Imagine you have a function that takes or returns a tuple.
-Especially if you use tuple unpacking (eg. ``x, y = get_point()``), adding additional data means that you have to change the invocation of that function *everywhere*.
-
-Adding an attribute to a class concerns only those who actually care about that attribute.
-
-
-…dicts?
--------
-
-Dictionaries are not for fixed fields.
-
-If you have a dict, it maps something to something else.
-You should be able to add and remove values.
-
-``attrs`` lets you be specific about those expectations; a dictionary does not.
-It gives you a named entity (the class) in your code, which lets you explain in other places whether you take a parameter of that class or return a value of that class.
-
-In other words: if your dict has a fixed and known set of keys, it is an object, not a hash.
-So if you never iterate over the keys of a dict, you should use a proper class.
-
-
-…hand-written classes?
-----------------------
-
-While we're fans of all things artisanal, writing the same nine methods again and again doesn't qualify.
-I usually manage to get some typos inside and there's simply more code that can break and thus has to be tested.
-

_service:tar_scm:attrs-22.1.0.tar.gz/.github/CONTRIBUTING.md -> _service:tar_scm:attrs-22.2.0.tar.gz/.github/CONTRIBUTING.md Changed

@@ -1,6 +1,6 @@
 # How To Contribute
 
-First off, thank you for considering contributing to `attrs`!
+Thank you for considering contributing to *attrs*!
 It's people like *you* who make it such a great tool for everyone.
 
 This document intends to make contribution more accessible by codifying tribal knowledge and expectations.
@@ -16,7 +16,7 @@
 In case you'd like to help out but don't want to deal with GitHub, there's a great opportunity:
 help your fellow developers on Stack Overflow(https://stackoverflow.com/questions/tagged/python-attrs)!
 
-The official tag is `python-attrs` and helping out in support frees us up to improve `attrs` instead!
+The official tag is `python-attrs` and helping out in support frees us up to improve *attrs* instead!
 
 
 ## Workflow
@@ -24,10 +24,10 @@
 - No contribution is too small!
   Please submit as many fixes for typos and grammar bloopers as you can!
 - Try to limit each pull request to *one* change only.
-- Since we squash on merge, it's up to you how you handle updates to the main branch.
-  Whether you prefer to rebase on main or merge main into your branch, do whatever is more comfortable for you.
+- Since we squash on merge, it's up to you how you handle updates to the `main` branch.
+  Whether you prefer to rebase on `main` or merge `main` into your branch, do whatever is more comfortable for you.
 - *Always* add tests and docs for your code.
-  This is a hard rule; patches with missing tests or documentation can't be merged.
+  This is a hard rule; patches with missing tests or documentation won't be merged.
 - Make sure your changes pass our CI.
   You won't get any feedback until it's green unless you ask for it.
 - For the CI to pass, the coverage must be 100%.
@@ -46,23 +46,23 @@
 First create a virtual environment(https://virtualenv.pypa.io/) so you don't break your system-wide Python installation.
 It’s out of scope for this document to list all the ways to manage virtual environments in Python, but if you don’t already have a pet way, take some time to look at tools like *direnv*(https://hynek.me/til/python-project-local-venvs/), *virtualfish*(https://virtualfish.readthedocs.io/), and *virtualenvwrapper*(https://virtualenvwrapper.readthedocs.io/).
 
-Next, get an up-to-date checkout of the `attrs` repository:
+Next, get an up-to-date checkout of the *attrs* repository:
 
 ```console
 $ git clone git@github.com:python-attrs/attrs.git
 ```
 
-or if you prefer to use git via `https`:
+or if you prefer to use *Git* via `https`:
 
 ```console
 $ git clone https://github.com/python-attrs/attrs.git
 ```
 
-Change into the newly created directory and **after activating your virtual environment** install an editable version of `attrs` along with its tests and docs requirements:
+Change into the newly created directory and **after activating your virtual environment** install an editable version of *attrs* along with its tests and docs requirements:
 
 ```console
 $ cd attrs
-$ python -m pip install --upgrade pip setuptools  # PLEASE don't skip this step
+$ python -m pip install --upgrade pip wheel setuptools  # PLEASE don't skip this step
 $ python -m pip install -e '.dev'
 ```
 
@@ -72,7 +72,10 @@
 $ python -m pytest
 ```
 
-should work and pass, as should:
+should work and pass.
+You can *significantly* speed up the test suite by passing `-n auto` to *pytest* which activates *pytest-xdist*(https://github.com/pytest-dev/pytest-xdist) and takes advantage of all your CPU cores.
+
+Documentation should also build:
 
 ```console
 $ cd docs
@@ -81,20 +84,22 @@
 
 The built documentation can then be found in `docs/_build/html/`.
 
-To avoid committing code that violates our style guide, we strongly advise you to install *pre-commit* ^dev hooks:
+---
+
+To avoid committing code that violates our style guide, we strongly advise you to install *pre-commit* and its hooks:
 
 ```console
 $ pre-commit install
 ```
 
-You can also run them anytime (as our *tox* does) using:
+This is not strictly necessary, because our *tox* file contains an environment that runs:
 
 ```console
 $ pre-commit run --all-files
 ```
 
-^dev: *pre-commit* should have been installed into your virtualenv automatically when you ran `pip install -e '.dev'` above.
-        If *pre-commit* is missing, your probably need to run `pip install -e '.dev'` again.
+and our CI has integration with pre-commit.ci(https://pre-commit.ci).
+But it's way more comfortable to run it locally and *git* catching avoidable errors.
 
 
 ## Code
@@ -170,16 +175,16 @@
 
 If your change is noteworthy, there needs to be a changelog entry so our users can learn about it!
 
-To avoid merge conflicts, we use the *towncrier*(https://pypi.org/project/towncrier) package to manage our changelog.
-*towncrier* uses independent files for each pull request – so called *news fragments* – instead of one monolithic changelog file.
-On release, those news fragments are compiled into our `CHANGELOG.rst`(https://github.com/python-attrs/attrs/blob/main/CHANGELOG.rst).
+To avoid merge conflicts, we use the *Towncrier*(https://pypi.org/project/towncrier) package to manage our changelog.
+*towncrier* uses independent *Markdown* files for each pull request – so called *news fragments* – instead of one monolithic changelog file.
+On release, those news fragments are compiled into our `CHANGELOG.md`(https://github.com/python-attrs/attrs/blob/main/CHANGELOG.md).
 
-You don't need to install *towncrier* yourself, you just have to abide by a few simple rules:
+You don't need to install *Towncrier* yourself, you just have to abide by a few simple rules:
 
-- For each pull request, add a new file into `changelog.d` with a filename adhering to the `pr#.(change|deprecation|breaking).rst` schema:
-  For example, `changelog.d/42.change.rst` for a non-breaking change that is proposed in pull request #42.
+- For each pull request, add a new file into `changelog.d` with a filename adhering to the `pr#.(change|deprecation|breaking).md` schema:
+  For example, `changelog.d/42.change.md` for a non-breaking change that is proposed in pull request #42.
 - As with other docs, please use semantic newlines within news fragments.
-- Wrap symbols like modules, functions, or classes into double backticks so they are rendered in a `monospace font`.
+- Wrap symbols like modules, functions, or classes into backticks so they are rendered in a `monospace font`.
 - Wrap arguments into asterisks like in docstrings:
   `Added new argument *an_argument*.`
 - If you mention functions or other callables, add parentheses at the end of their names:
@@ -191,19 +196,19 @@
   + Added `attrs.validators.func()`.
   + `attrs.func()` now doesn't crash the Large Hadron Collider anymore when passed the *foobar* argument.
 - If you want to reference multiple issues, copy the news fragment to another filename.
-  *towncrier* will merge all news fragments with identical contents into one entry with multiple links to the respective pull requests.
+  *Towncrier* will merge all news fragments with identical contents into one entry with multiple links to the respective pull requests.
 
 Example entries:
 
-  ```rst
-  Added ``attrs.validators.func()``.
+  ```md
+  Added `attrs.validators.func()`.
   The feature really *is* awesome.
   ```
 
 or:
 
-  ```rst
-  ``attrs.func()`` now doesn't crash the Large Hadron Collider anymore when passed the *foobar* argument.
+  ```md
+  `attrs.func()` now doesn't crash the Large Hadron Collider anymore when passed the *foobar* argument.
   The bug really *was* nasty.
   ```
 
@@ -214,7 +219,7 @@
 
 ## Governance
 
-`attrs` is maintained by team of volunteers(https://github.com/python-attrs) that is always open to new members that share our vision of a fast, lean, and magic-free library that empowers programmers to write better code with less effort.
+*attrs* is maintained by team of volunteers(https://github.com/python-attrs) that is always open to new members that share our vision of a fast, lean, and magic-free library that empowers programmers to write better code with less effort.
 If you'd like to join, just get a pull request merged and ask to be added in the very same pull request!
 
 **The simple rule is that everyone is welcome to review/merge pull requests of others but nobody is allowed to merge their own code.**

_service:tar_scm:attrs-22.1.0.tar.gz/.github/SECURITY.md -> _service:tar_scm:attrs-22.2.0.tar.gz/.github/SECURITY.md Changed

_service:tar_scm:attrs-22.2.0.tar.gz/.github/dependabot.yml Added

_service:tar_scm:attrs-22.2.0.tar.gz/.github/sponsors Added

_service:tar_scm:attrs-22.2.0.tar.gz/.github/sponsors/FilePreviews.svg Added

@@ -0,0 +1,1 @@
+<svg viewBox="0 0 180 60" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" clip-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2"><path fill="#fff" d="M0 0h180v60H0z"/><path fill="#fff" d="M0 0h180v60H0z"/><path d="M27.917 35.296v9.608h-5V15.662h20v5.013h-15v9.608h8.75v5.013h-8.75zM32.5 54.93c13.807 0 25-11.222 25-25.065C57.5 16.022 46.307 4.8 32.5 4.8s-25 11.222-25 25.065c0 13.843 11.193 25.065 25 25.065zm5.417-33.002v13.368h5V21.928h-5zm30.694.302h8.95v2.16h-6.483v3.81h6.11v2.08h-6.11v5.851h-2.467v-13.9zm10.165 4.477h2.35v9.424h-2.35v-9.424zm-.333-3.2c0-.38.14-.71.421-.992.28-.282.637-.422 1.068-.422.43 0 .793.134 1.086.402.294.268.441.606.441 1.012 0 .405-.146.742-.44 1.01-.295.269-.656.403-1.087.403-.431 0-.787-.14-1.068-.422a1.358 1.358 0 01-.42-.991zm4.957-2.22h2.35v14.844H83.4V21.288zm11.203 9.19c0-.301-.042-.59-.127-.864a1.97 1.97 0 00-.402-.727 1.96 1.96 0 00-.695-.5 2.422 2.422 0 00-.989-.187c-.705 0-1.302.213-1.792.638-.49.426-.76.972-.812 1.64h4.817zm2.35 1.06v.314c0 .104-.007.21-.02.314h-7.147a2.336 2.336 0 00.861 1.66c.248.202.529.363.842.48.314.118.64.177.98.177.587 0 1.083-.108 1.488-.324.405-.217.737-.514.998-.893l1.567 1.256c-.927 1.257-2.272 1.885-4.034 1.885a5.715 5.715 0 01-2.017-.344 4.75 4.75 0 01-1.596-.971 4.39 4.39 0 01-1.058-1.542c-.255-.609-.381-1.299-.381-2.07 0-.76.127-1.45.381-2.072a4.713 4.713 0 011.048-1.59c.444-.439.97-.78 1.576-1.022a5.272 5.272 0 011.969-.363c.653 0 1.256.108 1.811.324a3.93 3.93 0 011.44.962c.404.425.72.956.95 1.59.228.635.342 1.378.342 2.229zm1.764-9.307h4.524a9.82 9.82 0 012.154.216c.64.144 1.188.38 1.645.707.457.327.81.746 1.057 1.257.249.51.373 1.125.373 1.845 0 .773-.144 1.42-.431 1.944a3.498 3.498 0 01-1.165 1.266c-.49.32-1.061.553-1.714.698a9.62 9.62 0 01-2.076.216h-1.9v5.752h-2.467v-13.9zm4.191 6.067c.404 0 .79-.029 1.155-.088.366-.059.692-.164.98-.314.287-.151.515-.357.685-.619.17-.262.254-.602.254-1.02 0-.406-.084-.737-.254-.992a1.761 1.761 0 00-.676-.6c-.28-.143-.6-.238-.96-.284a8.718 8.718 0 00-1.106-.069h-1.801v3.986h1.723zm6.112-1.59h2.252v1.57h.039a3.43 3.43 0 011.097-1.335c.47-.34 1.018-.51 1.645-.51.091 0 .189.003.293.01.105.007.196.023.274.049v2.16a2.728 2.728 0 00-.724-.098c-.536 0-.966.098-1.292.294a2.344 2.344 0 00-.764.707 2.534 2.534 0 00-.372.844 3.289 3.289 0 00-.098.687v5.046h-2.35v-9.424zm12.77 3.77c0-.301-.043-.59-.127-.864a1.97 1.97 0 00-.402-.727 1.96 1.96 0 00-.696-.5 2.42 2.42 0 00-.988-.187c-.705 0-1.302.213-1.792.638-.49.426-.76.972-.813 1.64h4.818zm2.35 1.06v.314c0 .104-.007.21-.02.314h-7.148a2.336 2.336 0 00.862 1.66c.248.202.529.363.842.48.313.118.64.177.979.177.588 0 1.083-.108 1.488-.324a2.813 2.813 0 001-.893l1.566 1.256c-.927 1.257-2.272 1.885-4.034 1.885a5.716 5.716 0 01-2.017-.344 4.748 4.748 0 01-1.596-.971 4.39 4.39 0 01-1.058-1.542c-.255-.609-.382-1.299-.382-2.07 0-.76.127-1.45.382-2.072a4.718 4.718 0 011.048-1.59c.443-.439.969-.78 1.576-1.022a5.272 5.272 0 011.968-.363c.653 0 1.257.108 1.812.324a3.93 3.93 0 011.44.962c.404.425.72.956.95 1.59.228.635.342 1.378.342 2.229zm.236-4.83h2.566l2.467 6.872h.04l2.486-6.872h2.487l-3.74 9.424h-2.506l-3.8-9.424zm10.87 0h2.35v9.424h-2.35v-9.424zm-.332-3.2c0-.38.14-.71.42-.992.281-.282.637-.422 1.068-.422.431 0 .793.134 1.087.402.293.268.44.606.44 1.012 0 .405-.146.742-.44 1.01-.294.269-.656.403-1.087.403-.43 0-.786-.14-1.067-.422a1.358 1.358 0 01-.421-.991zm11.536 6.97c0-.301-.043-.59-.127-.864a1.973 1.973 0 00-.402-.727 1.958 1.958 0 00-.695-.5 2.42 2.42 0 00-.989-.187c-.705 0-1.302.213-1.792.638-.49.426-.76.972-.812 1.64h4.817zm2.35 1.06v.314c0 .104-.007.21-.02.314h-7.147a2.336 2.336 0 00.861 1.66c.248.202.529.363.842.48.314.118.64.177.98.177.587 0 1.083-.108 1.488-.324a2.81 2.81 0 00.999-.893l1.566 1.256c-.927 1.257-2.271 1.885-4.034 1.885a5.717 5.717 0 01-2.017-.344 4.751 4.751 0 01-1.596-.971 4.385 4.385 0 01-1.057-1.542c-.255-.609-.383-1.299-.383-2.07 0-.76.128-1.45.382-2.072a4.709 4.709 0 011.048-1.59c.444-.439.97-.78 1.577-1.022a5.271 5.271 0 011.968-.363c.653 0 1.256.108 1.811.324a3.926 3.926 0 011.44.962c.404.425.72.956.95 1.59.228.635.342 1.378.342 2.229zm.315-4.83h2.546l1.958 6.754h.04l2.016-6.754h2.507l2.037 6.754h.039l1.998-6.754h2.448l-3.252 9.424h-2.388l-2.135-6.597h-.04l-2.114 6.597h-2.39l-3.27-9.424zm21.602 2.513a2.709 2.709 0 00-.862-.717 2.42 2.42 0 00-1.194-.304c-.379 0-.725.079-1.038.236-.313.157-.47.419-.47.785 0 .367.173.625.52.776.346.15.85.304 1.517.461.352.078.708.184 1.067.314.36.131.685.304.98.52.294.217.531.485.714.806.183.32.274.71.274 1.168 0 .576-.107 1.063-.323 1.463a2.757 2.757 0 01-.861.971 3.612 3.612 0 01-1.254.54c-.476.111-.97.167-1.479.167a5.853 5.853 0 01-2.134-.402c-.692-.27-1.267-.651-1.724-1.149l1.548-1.453c.26.34.6.622 1.018.844a2.91 2.91 0 001.39.334c.17 0 .343-.02.52-.059.176-.039.339-.101.49-.186.15-.085.27-.2.361-.344a.972.972 0 00.137-.53c0-.393-.179-.674-.538-.844-.36-.17-.898-.34-1.616-.51a7.739 7.739 0 01-1.028-.305 3.363 3.363 0 01-.891-.49 2.275 2.275 0 01-.627-.757c-.156-.3-.235-.674-.235-1.119 0-.524.108-.975.324-1.355.215-.38.499-.69.851-.932a3.814 3.814 0 011.195-.54c.444-.118.9-.177 1.37-.177.68 0 1.342.118 1.988.353.646.236 1.16.596 1.538 1.08l-1.528 1.355z" fill="#1083ff"/></svg>

_service:tar_scm:attrs-22.2.0.tar.gz/.github/sponsors/Sentry.svg Added

@@ -0,0 +1,1 @@
+<svg viewBox="0 0 180 60" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" clip-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2"><path fill="#fff" d="M0 0h180v60H0z"/><path d="M29.612 13.2a3.974 3.974 0 00-3.4-1.922c-1.391 0-2.684.73-3.402 1.922l-5.594 9.582a27.415 27.415 0 0115.091 22.666H28.38a23.56 23.56 0 00-13.144-19.317l-5.178 8.953a13.547 13.547 0 017.847 10.347h-9.02a.649.649 0 01-.528-.943l2.5-4.251A9.143 9.143 0 008 38.62l-2.474 4.251a3.862 3.862 0 001.437 5.306c.587.33 1.248.506 1.922.51h12.354a16.511 16.511 0 00-6.802-14.717l1.964-3.402a20.317 20.317 0 018.757 18.119h10.466A30.537 30.537 0 0021.671 21.65l3.97-6.802a.658.658 0 01.893-.23c.451.247 17.251 29.562 17.566 29.903a.645.645 0 01-.564.96h-4.061a34.338 34.338 0 010 3.24h4.089a3.92 3.92 0 003.903-3.903v-.017a3.82 3.82 0 00-.527-1.938L29.612 13.2zm81.043 22.122l-12.55-16.205h-3.128V40.84h3.171V24.193l12.907 16.647h2.772V19.117h-3.172v16.205zm-31.603-4.03h11.249V28.47H79.044V21.93h12.694V19.11H75.813V40.84H91.9v-2.823H79.044l.008-6.725zm-13.229-2.755c-4.378-1.054-5.603-1.887-5.603-3.91 0-1.82 1.607-3.053 4.005-3.053 2.183.064 4.29.824 6.01 2.168l1.701-2.406a11.992 11.992 0 00-7.652-2.55c-4.302 0-7.303 2.55-7.303 6.18 0 3.912 2.55 5.264 7.192 6.394 4.133.952 5.4 1.837 5.4 3.818 0 1.98-1.701 3.205-4.328 3.205-2.615-.012-5.133-1-7.057-2.772l-1.913 2.287a13.554 13.554 0 008.86 3.274c4.658 0 7.651-2.508 7.651-6.386-.025-3.281-1.963-5.041-6.963-6.249zm105.521-9.42l-6.538 10.203-6.496-10.203h-3.792l8.579 13.136v8.596h3.265V32.15L175 19.117h-3.656zm-54.95 2.942h7.116v18.79h3.265v-18.79h7.117v-2.942h-17.49l-.008 2.942zm32.598 10.304c3.281-.91 5.101-3.205 5.101-6.487 0-4.174-3.052-6.801-7.975-6.801h-9.658v21.757h3.23v-7.805h5.484l5.51 7.822h3.775l-5.952-8.35.485-.136zm-9.31-2.125v-8.247h6.096c3.18 0 5 1.505 5 4.115 0 2.61-1.948 4.132-4.966 4.132h-6.13z" fill="#362d59" fill-rule="nonzero"/></svg>

_service:tar_scm:attrs-22.2.0.tar.gz/.github/sponsors/Tidelift.svg Added

@@ -0,0 +1,1 @@
+<svg viewBox="0 0 180 60" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" clip-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2"><path fill="#fff" d="M0 0h180v60H0z"/><g fill-rule="nonzero"><path d="M39.99 39.07V20.93c0-1.838 0-1.838 1.937-1.838s1.937 0 1.937 1.837v18.142c0 1.837 0 1.837-1.937 1.837s-1.937 0-1.937-1.837zm9.422-1.04V21.97c0-2.883 0-2.883 2.883-2.883h4.699c6.294 0 10.168 3.142 10.58 8.259a25.26 25.26 0 010 4.483c-.416 5.084-4.29 9.08-10.58 9.08h-4.699c-2.883 0-2.883 0-2.883-2.88zm7.498-.797c4.308 0 6.524-2.433 6.774-5.779a20.04 20.04 0 000-3.72c-.284-3.38-2.466-4.963-6.774-4.963h-3.62v14.462h3.62zm15.855.797V21.97c0-2.883 0-2.883 2.882-2.883h10.914c1.904 0 1.904 0 1.904 1.788 0 1.787 0 1.82-1.904 1.82h-9.914v5.617h8.96c1.82 0 1.82 0 1.82 1.705 0 1.704 0 1.72-1.82 1.72h-8.96V37.3h9.998c1.903 0 1.903 0 1.903 1.77 0 1.838 0 1.838-1.903 1.838H75.647c-2.882 0-2.882 0-2.882-2.879zm21.261 0V20.945c0-1.871 0-1.871 1.92-1.871s1.937 0 1.937 1.837V37.3h9.64c1.953 0 1.953 0 1.953 1.82 0 1.822 0 1.788-1.953 1.788H96.909c-2.883 0-2.883 0-2.883-2.879zm20.944 1.04V20.93c0-1.838 0-1.838 1.938-1.838 1.937 0 1.937 0 1.937 1.837v18.142c0 1.837 0 1.837-1.937 1.837s-1.937 0-1.937-1.837zm9.378 0V21.988c0-2.883 0-2.883 2.882-2.883h10.914c1.87 0 1.887 0 1.887 1.821 0 1.82 0 1.787-1.887 1.787h-9.918v5.834h9.193c1.887 0 1.887 0 1.887 1.754s0 1.788-1.887 1.788h-9.193v6.983c0 1.837 0 1.837-1.937 1.837s-1.941 0-1.941-1.837zM32.533 19.092H17.346c-1.987 0-1.987 0-1.987 1.82 0 1.821 0 1.788 1.987 1.788h5.665v6.437l3.857-3.025V22.7h5.665c1.954 0 1.954 0 1.954-1.788 0-1.787 0-1.82-1.954-1.82z" fill="#4b5168"/><path d="M23.01 32.87v6.15c0 1.838 0 1.838 1.938 1.838 1.937 0 1.92 0 1.92-1.87v-9.142l-3.857 3.025z" fill="#f6914d"/><path d="M147.463 19.092h15.187c1.987 0 1.987 0 1.987 1.82 0 1.821 0 1.788-1.987 1.788h-5.665v6.437l-3.857-3.025V22.7h-5.665c-1.954 0-1.954 0-1.954-1.788 0-1.787.004-1.82 1.954-1.82z" fill="#4b5168"/><path d="M156.99 32.87v6.15c0 1.838 0 1.838-1.938 1.838-1.937 0-1.92 0-1.92-1.87v-9.142l3.857 3.025z" fill="#f6914d"/></g></svg>

_service:tar_scm:attrs-22.2.0.tar.gz/.github/sponsors/Variomedia.svg Added

@@ -0,0 +1,1 @@
+<svg viewBox="0 0 180 60" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" clip-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2"><path fill="#fff" d="M0 0h180v60H0z"/><g fill-rule="nonzero"><path d="M39.98 2.528c-.986 0-1.777.796-1.777 1.781 0 .324.087.627.238.888l18.6 38.156 6.966-17.195L53.047 3.61a1.783 1.783 0 00-1.566-1.08H39.979z" fill="#3386aa"/><path d="M74.781 2.53c-.77 0-1.424.482-1.674 1.166L57.039 43.354l6.33 13.01c.294.656.905 1.107 1.65 1.107.73 0 1.366-.38 1.716-1.177l20.67-51.241c.094-.23.166-.479.166-.745 0-.986-.797-1.772-1.781-1.779H74.78z" fill="#2ac2ba"/><path d="M89.969 55.009a1.795 1.795 0 001.656 2.463l11.005-.002c.742 0 1.379-.458 1.647-1.102l.003-.002 20.718-51.39a1.782 1.782 0 00-1.652-2.447h-11.011a1.77 1.77 0 00-1.665 1.148L89.969 55.009z" fill="#ec1e79"/><path d="M64.006 26.16l-1.763-3.629-5.204 20.823.63-1.554 6.337-15.64z" fill="#276680"/><path d="M89.873 56.02v-.002l-.009-.05v-.002a1.844 1.844 0 01-.022-.225v-.008c0-.018 0-.035-.002-.053v-.008c0-.236.047-.458.13-.664 1.946-4.833 7.794-19.328 7.794-19.328l.07-.175L87.52 3.88l.01.044c.002.015.006.03.009.044v.001l.008.044v.001l.006.044v.001l.006.045v.001l.005.045v.002l.002.045c.001.024.003.048.003.073v.065c0 .047-.004.094-.01.141 0 .016-.003.03-.005.046-.001.016-.004.03-.007.046l-.008.045v.002l-.01.043v.002l-.01.042v.003a.29.29 0 01-.011.04l-.001.006a.303.303 0 01-.011.039l-.002.007-.011.037-.003.009c-.004.01-.006.022-.01.034l-.005.013a.2.2 0 01-.011.03l-.006.016-.01.027-.008.022a.58.58 0 01-.025.061L79.586 24.43l10.322 31.74a2.272 2.272 0 01-.035-.15zm51.863-.782L125.07 3.863a1.776 1.776 0 01-.072 1.113L118.6 20.85l-1.445 3.584 10.333 31.786a1.79 1.79 0 001.701 1.25h10.838a1.777 1.777 0 001.71-2.233z" fill="#b1175b"/><path d="M118.86 29.685l-1.706-5.25 7.828-19.417-6.123 24.667zm-37.565 0l-1.707-5.25L87.42 5.02l-6.125 24.666zm14.83.581l1.709 5.24-7.831 19.417 6.122-24.657z" fill="#841245"/></g></svg>

_service:tar_scm:attrs-22.2.0.tar.gz/.github/workflows/build-docset.yml Added

_service:tar_scm:attrs-22.2.0.tar.gz/.github/workflows/ci.yml Added

@@ -0,0 +1,226 @@
+---
+name: CI
+
+on:
+  push:
+    branches: main
+    tags: "*"
+  pull_request:
+    branches: main
+  workflow_dispatch:
+
+env:
+  FORCE_COLOR: "1" # Make tools pretty.
+  TOX_TESTENV_PASSENV: FORCE_COLOR
+  PIP_DISABLE_PIP_VERSION_CHECK: "1"
+  PIP_NO_PYTHON_VERSION_WARNING: "1"
+  PYTHON_LATEST: "3.11"
+
+permissions:
+  contents: read
+
+jobs:
+  tests:
+    name: tox on ${{ matrix.python-version }}
+    runs-on: ubuntu-20.04
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version:
+          - "3.6"
+          - "3.7"
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+          - "~3.12.0-0"
+          - "pypy-3.7"
+          - "pypy-3.8"
+
+    continue-on-error: >-
+      ${{ contains(matrix.python-version, '~') && true || false }}
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
+            files.pythonhosted.org:443
+            github.com:443
+            objects.githubusercontent.com:443
+            pypi.org:443
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -VV
+          python -m site
+          python -m pip install --upgrade wheel tox tox-gh-actions
+
+      - run: python -m tox
+
+      - name: Upload coverage data
+        uses: actions/upload-artifact@v3
+        with:
+          name: coverage-data
+          path: .coverage.*
+          if-no-files-found: ignore
+
+  coverage:
+    runs-on: ubuntu-latest
+    needs: tests
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+            api.github.com:443
+
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          # Use latest Python, so it understands all syntax.
+          python-version: ${{env.PYTHON_LATEST}}
+
+      - run: python -m pip install --upgrade coveragetoml
+
+      - name: Download coverage data
+        uses: actions/download-artifact@v3
+        with:
+          name: coverage-data
+
+      - name: Combine coverage and fail if it's <100%.
+        run: |
+          python -m coverage combine
+          python -m coverage html --skip-covered --skip-empty
+          python -m coverage report --fail-under=100
+
+      - name: Upload HTML report if check failed.
+        uses: actions/upload-artifact@v3
+        with:
+          name: html-report
+          path: htmlcov
+        if: ${{ failure() }}
+
+  docs:
+    name: Build docs & run doctests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            docs.python.org:443
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+
+      - run: python -m pip install --upgrade wheel tox
+      - run: python -m tox -e docs
+
+  pyright:
+    name: Check types using pyright
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            files.pythonhosted.org:443
+            github.com:443
+            nodejs.org:443
+            pypi.org:443
+            registry.npmjs.org:443
+            api.github.com:443
+
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{env.PYTHON_LATEST}}
+
+      - run: python -m pip install --upgrade wheel tox
+      - run: python -m tox -e pyright
+
+  package:
+    name: Build & verify package
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+
+      - uses: actions/checkout@v3
+      - uses: hynek/build-and-inspect-python-package@v1
+
+  install-dev:
+    name: Verify dev env
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: ubuntu-latest, windows-latest
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+            api.github.com:443
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{env.PYTHON_LATEST}}

_service:tar_scm:attrs-22.2.0.tar.gz/.github/workflows/codeql-analysis.yml Added

@@ -0,0 +1,51 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: "main"
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: "main"
+  schedule:
+    - cron: "30 22 * * 4"
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: "python"
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            api.github.com:443
+            bootstrap.pypa.io:443
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+            uploads.github.com:443
+
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2

_service:tar_scm:attrs-22.2.0.tar.gz/.github/workflows/pypi-package.yml Added

@@ -0,0 +1,78 @@
+---
+name: Deploy to (Test-) PyPI
+
+on:
+  push:
+    tags: "*"
+  release:
+    types:
+      - published
+
+permissions:
+  contents: read
+
+jobs:
+  release-test-pypi:
+    # Upload to Test PyPI on every pushed tag.
+    environment: release-test-pypi
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          # Need the real pypi.org for installations.
+          allowed-endpoints: >
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+            test.pypi.org:443
+
+      - uses: actions/checkout@v3
+        # with:
+        #   fetch-depth: 0
+
+      - name: Build package
+        run: |
+          python -m pip install -U build twine wheel
+          python -m build
+          twine check --strict dist/*
+
+      - name: Publish package to Test PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          repository_url: https://test.pypi.org/legacy/
+
+  release-pypi:
+    # Upload to real PyPI on GitHub Releases.
+    environment: release-pypi
+    if: github.event.action == 'published'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@v2
+        with:
+          egress-policy: block
+          allowed-endpoints: >
+            files.pythonhosted.org:443
+            github.com:443
+            pypi.org:443
+
+      - uses: actions/checkout@v3
+        # with:
+        #   fetch-depth: 0
+
+      - name: Build package
+        run: |
+          python -m pip install -U build twine wheel
+          python -m build
+          twine check --strict dist/*
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

_service:tar_scm:attrs-22.1.0.tar.gz/.gitignore -> _service:tar_scm:attrs-22.2.0.tar.gz/.gitignore Changed

_service:tar_scm:attrs-22.1.0.tar.gz/.pre-commit-config.yaml -> _service:tar_scm:attrs-22.2.0.tar.gz/.pre-commit-config.yaml Changed

@@ -7,15 +7,15 @@
 
 repos:
   - repo: https://github.com/psf/black
-    rev: 22.6.0
+    rev: 22.10.0
     hooks:
       - id: black
 
   - repo: https://github.com/asottile/pyupgrade
-    rev: v2.37.3
+    rev: v3.3.0
     hooks:
       - id: pyupgrade
-        args: --py3-plus, --keep-percent-format
+        args: --py36-plus, --keep-percent-format
         exclude: "tests/test_slots.py"
 
   - repo: https://github.com/PyCQA/isort
@@ -25,21 +25,24 @@
         additional_dependencies: toml
         files: \.py$
 
+  - repo: https://github.com/asottile/yesqa
+    rev: v1.4.0
+    hooks:
+      - id: yesqa
+
   - repo: https://github.com/PyCQA/flake8
-    rev: 4.0.1
+    rev: 6.0.0
     hooks:
       - id: flake8
-        language_version: python3.10
 
   - repo: https://github.com/econchick/interrogate
     rev: 1.5.0
     hooks:
       - id: interrogate
         args: tests
-        language_version: python3.10
 
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
+    rev: v4.4.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer

_service:tar_scm:attrs-22.2.0.tar.gz/CHANGELOG.md Added

@@ -0,0 +1,1064 @@
+# Changelog
+
+Versions follow CalVer(https://calver.org) with a strict backwards-compatibility policy.
+
+The **first number** of the version is the year.
+The **second number** is incremented with each release, starting at 1 for each year.
+The **third number** is when we need to start branches for older releases (only for emergencies).
+
+Put simply, you shouldn't ever be afraid to upgrade `attrs` if you're only using its public APIs.
+Whenever there is a need to break compatibility, it is announced here in the changelog, and raises a `DeprecationWarning` for a year (if possible) before it's finally really broken.
+
+> **Warning**
+> The structure of the `attrs.Attribute` class is exempt from this rule.
+> It *will* change in the future, but since it should be considered read-only, that shouldn't matter.
+>
+> However if you intend to build extensions on top of `attrs` you have to anticipate that.
+
+
+Changes for the upcoming release can be found in the "changelog.d" directory(https://github.com/python-attrs/attrs/tree/main/changelog.d) in our repository.
+
+
+
+## 22.2.0(https://github.com/python-attrs/attrs/tree/22.2.0) - 2022-12-21
+
+### Backwards-incompatible Changes
+
+- Python 3.5 is not supported anymore.
+  #988(https://github.com/python-attrs/attrs/issues/988)
+
+
+### Deprecations
+
+- Python 3.6 is now deprecated and support will be removed in the next release.
+  #1017(https://github.com/python-attrs/attrs/issues/1017)
+
+
+### Changes
+
+- `attrs.field()` now supports an *alias* option for explicit `__init__` argument names.
+
+  Get `__init__` signatures matching any taste, peculiar or plain!
+  The PEP 681 compatible(https://peps.python.org/pep-0681/#field-specifier-parameters) *alias* option can be use to override private attribute name mangling, or add other arbitrary field argument name overrides.
+  #950(https://github.com/python-attrs/attrs/issues/950)
+- `attrs.NOTHING` is now an enum value, making it possible to use with e.g. `typing.Literal`(https://docs.python.org/3/library/typing.html#typing.Literal).
+  #983(https://github.com/python-attrs/attrs/issues/983)
+- Added missing re-import of `attr.AttrsInstance` to the `attrs` namespace.
+  #987(https://github.com/python-attrs/attrs/issues/987)
+- Fix slight performance regression in classes with custom `__setattr__` and speedup even more.
+  #991(https://github.com/python-attrs/attrs/issues/991)
+- Class-creation performance improvements by switching performance-sensitive templating operations to f-strings.
+
+  You can expect an improvement of about 5% -- even for very simple classes.
+  #995(https://github.com/python-attrs/attrs/issues/995)
+- `attrs.has()` is now a `TypeGuard`(https://docs.python.org/3/library/typing.html#typing.TypeGuard) for `AttrsInstance`.
+  That means that type checkers know a class is an instance of an `attrs` class if you check it using `attrs.has()` (or `attr.has()`) first.
+  #997(https://github.com/python-attrs/attrs/issues/997)
+- Made `attrs.AttrsInstance` stub available at runtime and fixed type errors related to the usage of `attrs.AttrsInstance` in *Pyright*.
+  #999(https://github.com/python-attrs/attrs/issues/999)
+- On Python 3.10 and later, call `abc.update_abstractmethods()`(https://docs.python.org/3/library/abc.html#abc.update_abstractmethods) on dict classes after creation.
+  This improves the detection of abstractness.
+  #1001(https://github.com/python-attrs/attrs/issues/1001)
+- *attrs*'s pickling methods now use dicts instead of tuples.
+  That is safer and more robust across different versions of a class.
+  #1009(https://github.com/python-attrs/attrs/issues/1009)
+- Added `attrs.validators.not_(wrapped_validator)` to logically invert *wrapped_validator* by accepting only values where *wrapped_validator* rejects the value with a `ValueError` or `TypeError` (by default, exception types configurable).
+  #1010(https://github.com/python-attrs/attrs/issues/1010)
+- The type stubs for `attrs.cmp_using()` now have default values.
+  #1027(https://github.com/python-attrs/attrs/issues/1027)
+- To conform with PEP 681(https://peps.python.org/pep-0681/), `attr.s()` and `attrs.define()` now accept *unsafe_hash* in addition to *hash*.
+  #1065(https://github.com/python-attrs/attrs/issues/1065)
+
+
+## 22.1.0(https://github.com/python-attrs/attrs/tree/22.1.0) - 2022-07-28
+
+### Backwards-incompatible Changes
+
+- Python 2.7 is not supported anymore.
+
+  Dealing with Python 2.7 tooling has become too difficult for a volunteer-run project.
+
+  We have supported Python 2 more than 2 years after it was officially discontinued and feel that we have paid our dues.
+  All version up to 21.4.0 from December 2021 remain fully functional, of course.
+  #936(https://github.com/python-attrs/attrs/issues/936)
+
+- The deprecated `cmp` attribute of `attrs.Attribute` has been removed.
+  This does not affect the *cmp* argument to `attr.s` that can be used as a shortcut to set *eq* and *order* at the same time.
+  #939(https://github.com/python-attrs/attrs/issues/939)
+
+
+### Changes
+
+- Instantiation of frozen slotted classes is now faster.
+  #898(https://github.com/python-attrs/attrs/issues/898)
+- If an `eq` key is defined, it is also used before hashing the attribute.
+  #909(https://github.com/python-attrs/attrs/issues/909)
+- Added `attrs.validators.min_len()`.
+  #916(https://github.com/python-attrs/attrs/issues/916)
+- `attrs.validators.deep_iterable()`'s *member_validator* argument now also accepts a list of validators and wraps them in an `attrs.validators.and_()`.
+  #925(https://github.com/python-attrs/attrs/issues/925)
+- Added missing type stub re-imports for `attrs.converters` and `attrs.filters`.
+  #931(https://github.com/python-attrs/attrs/issues/931)
+- Added missing stub for `attr(s).cmp_using()`.
+  #949(https://github.com/python-attrs/attrs/issues/949)
+- `attrs.validators._in()`'s `ValueError` is not missing the attribute, expected options, and the value it got anymore.
+  #951(https://github.com/python-attrs/attrs/issues/951)
+- Python 3.11 is now officially supported.
+  #969(https://github.com/python-attrs/attrs/issues/969)
+
+
+## 21.4.0(https://github.com/python-attrs/attrs/tree/21.4.0) - 2021-12-29
+
+### Changes
+
+- Fixed the test suite on PyPy3.8 where `cloudpickle` does not work.
+  #892(https://github.com/python-attrs/attrs/issues/892)
+- Fixed `coverage report` for projects that use `attrs` and don't set a `--source`.
+  #895(https://github.com/python-attrs/attrs/issues/895),
+  #896(https://github.com/python-attrs/attrs/issues/896)
+
+
+## 21.3.0(https://github.com/python-attrs/attrs/tree/21.3.0) - 2021-12-28
+
+### Backward-incompatible Changes
+
+- When using `@define`, converters are now run by default when setting an attribute on an instance -- additionally to validators.
+  I.e. the new default is `on_setattr=attrs.setters.convert, attrs.setters.validate`.
+
+  This is unfortunately a breaking change, but it was an oversight, impossible to raise a `DeprecationWarning` about, and it's better to fix it now while the APIs are very fresh with few users.
+  #835(https://github.com/python-attrs/attrs/issues/835),
+  #886(https://github.com/python-attrs/attrs/issues/886)
+
+- `import attrs` has finally landed!
+  As of this release, you can finally import `attrs` using its proper name.
+
+  Not all names from the `attr` namespace have been transferred; most notably `attr.s` and `attr.ib` are missing.
+  See `attrs.define` and `attrs.field` if you haven't seen our next-generation APIs yet.
+  A more elaborate explanation can be found On The Core API Names(https://www.attrs.org/en/latest/names.html)
+
+  This feature is at least for one release **provisional**.
+  We don't *plan* on changing anything, but such a big change is unlikely to go perfectly on the first strike.
+
+  The API docs have been mostly updated, but it will be an ongoing effort to change everything to the new APIs.
+  Please note that we have **not** moved -- or even removed -- anything from `attr`!
+
+  Please do report any bugs or documentation inconsistencies!
+  #887(https://github.com/python-attrs/attrs/issues/887)
+
+
+### Changes
+
+- `attr.asdict(retain_collection_types=False)` (default) dumps collection-esque keys as tuples.
+  #646(https://github.com/python-attrs/attrs/issues/646),
+  #888(https://github.com/python-attrs/attrs/issues/888)
+- `__match_args__` are now generated to support Python 3.10's
+  Structural Pattern Matching(https://docs.python.org/3.10/whatsnew/3.10.html#pep-634-structural-pattern-matching).
+  This can be controlled by the `match_args` argument to the class decorators on Python 3.10 and later.
+  On older versions, it is never added and the argument is ignored.
+  #815(https://github.com/python-attrs/attrs/issues/815)
+- If the class-level *on_setattr* is set to `attrs.setters.validate` (default in `@define` and `@mutable`) but no field defines a validator, pretend that it's not set.
+  #817(https://github.com/python-attrs/attrs/issues/817)
+- The generated `__repr__` is significantly faster on Pythons with f-strings.
+  #819(https://github.com/python-attrs/attrs/issues/819)
+- Attributes transformed via `field_transformer` are wrapped with `AttrsClass` again.
+  #824(https://github.com/python-attrs/attrs/issues/824)
+- Generated source code is now cached more efficiently for identical classes.
+  #828(https://github.com/python-attrs/attrs/issues/828)
+- Added `attrs.converters.to_bool()`.
+  #830(https://github.com/python-attrs/attrs/issues/830)
+- `attrs.resolve_types()` now resolves types of subclasses after the parents are resolved.
+  #842(https://github.com/python-attrs/attrs/issues/842)
+  #843(https://github.com/python-attrs/attrs/issues/843)
+- Added new validators: `lt(val)` (\< val), `le(va)` (≤ val), `ge(val)` (≥ val), `gt(val)` (> val), and `maxlen(n)`.
+  #845(https://github.com/python-attrs/attrs/issues/845)
+- `attrs` classes are now fully compatible with cloudpickle(https://github.com/cloudpipe/cloudpickle) (no need to disable `repr` anymore).
+  #857(https://github.com/python-attrs/attrs/issues/857)
+- Added new context manager `attrs.validators.disabled()` and functions `attrs.validators.(set|get)_disabled()`.
+  They deprecate `attrs.(set|get)_run_validators()`.
+  All functions are interoperable and modify the same internal state.
+  They are not – and never were – thread-safe, though.
+  #859(https://github.com/python-attrs/attrs/issues/859)
+- `attrs.validators.matches_re()` now accepts pre-compiled regular expressions in addition to pattern strings.
+  #877(https://github.com/python-attrs/attrs/issues/877)
+
+---
+
+## 21.2.0(https://github.com/python-attrs/attrs/tree/21.2.0) - 2021-05-07
+
+### Backward-incompatible Changes
+
+- We had to revert the recursive feature for `attr.evolve()` because it broke some use-cases -- sorry!
+  #806(https://github.com/python-attrs/attrs/issues/806)
+- Python 3.4 is now blocked using packaging metadata because `attrs` can't be imported on it anymore.
+  To ensure that 3.4 users can keep installing  `attrs` easily, we will yank(https://pypi.org/help/#yanked) 21.1.0 from PyPI.
+  This has **no** consequences if you pin `attrs` to 21.1.0.
+  #807(https://github.com/python-attrs/attrs/issues/807)
+
+
+## 21.1.0(https://github.com/python-attrs/attrs/tree/21.1.0) - 2021-05-06
+

_service:tar_scm:attrs-22.2.0.tar.gz/CITATION.cff Added

_service:tar_scm:attrs-22.1.0.tar.gz/MANIFEST.in -> _service:tar_scm:attrs-22.2.0.tar.gz/MANIFEST.in Changed

_service:tar_scm:attrs-22.2.0.tar.gz/README.md Added

@@ -0,0 +1,157 @@
+<p align="center">
+   <a href="https://www.attrs.org/">
+      <picture>
+         <source srcset="https://raw.githubusercontent.com/python-attrs/attrs/main/docs/_static/attrs_logo_white.svg" media="(prefers-color-scheme: dark)">
+         <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/docs/_static/attrs_logo.svg" width="35%" alt="attrs" />
+      </picture>
+   </a>
+</p>
+
+
+
+<p align="center">
+   <a href="https://www.attrs.org/en/stable/">
+       <img src="https://img.shields.io/badge/Docs-RTD-black" alt="Documentation" />
+   </a>
+   <a href="https://github.com/python-attrs/attrs/blob/main/LICENSE">
+      <img src="https://img.shields.io/badge/license-MIT-C06524" alt="License: MIT" />
+   </a>
+   <a href="https://bestpractices.coreinfrastructure.org/projects/6482"><img src="https://bestpractices.coreinfrastructure.org/projects/6482/badge"></a>
+   <a href="https://pypi.org/project/attrs/">
+      <img src="https://img.shields.io/pypi/v/attrs" />
+   </a>
+   <a href="https://pepy.tech/project/attrs">
+      <img src="https://static.pepy.tech/personalized-badge/attrs?period=month&units=international_system&left_color=grey&right_color=blue&left_text=Downloads%20/%20Month" alt="Downloads per month" />
+   </a>
+   <a href="https://zenodo.org/badge/latestdoi/29918975"><img src="https://zenodo.org/badge/29918975.svg" alt="DOI"></a>
+</p>
+
+
+
+*attrs* is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka dunder methods(https://www.attrs.org/en/latest/glossary.html#term-dunder-methods)).
+Trusted by NASA(https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/personalizing-your-profile#list-of-qualifying-repositories-for-mars-2020-helicopter-contributor-achievement) for Mars missions since 2020!
+
+Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
+
+
+## Sponsors
+
+*attrs* would not be possible without our amazing sponsors(https://github.com/sponsors/hynek).
+Especially those generously supporting us at the *The Organization* tier and higher:
+
+<p align="center">
+   <a href="https://www.variomedia.de/">
+      <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/.github/sponsors/Variomedia.svg" width="200" height="60"></img>
+   </a>
+
+   <a href="https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo">
+      <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/.github/sponsors/Tidelift.svg" width="200" height="60"></img>
+   </a>
+
+   <a href="https://sentry.io/">
+      <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/.github/sponsors/Sentry.svg" width="200" height="60"></img>
+   </a>
+
+   <a href="https://filepreviews.io/">
+      <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/.github/sponsors/FilePreviews.svg" width="200" height="60"></img>
+   </a>
+</p>
+
+<p align="center">
+   <strong>Please consider <a href="https://github.com/sponsors/hynek">joining them</a> to help make <em>attrs</em>’s maintenance more sustainable!</strong>
+</p>
+
+
+
+## Example
+
+*attrs* gives you a class decorator and a way to declaratively define the attributes on that class:
+
+
+
+```pycon
+>>> from attrs import asdict, define, make_class, Factory
+
+>>> @define
+... class SomeClass:
+...     a_number: int = 42
+...     list_of_numbers: listint = Factory(list)
+...
+...     def hard_math(self, another_number):
+...         return self.a_number + sum(self.list_of_numbers) * another_number
+
+
+>>> sc = SomeClass(1, 1, 2, 3)
+>>> sc
+SomeClass(a_number=1, list_of_numbers=1, 2, 3)
+
+>>> sc.hard_math(3)
+19
+>>> sc == SomeClass(1, 1, 2, 3)
+True
+>>> sc != SomeClass(2, 3, 2, 1)
+True
+
+>>> asdict(sc)
+{'a_number': 1, 'list_of_numbers': 1, 2, 3}
+
+>>> SomeClass()
+SomeClass(a_number=42, list_of_numbers=)
+
+>>> C = make_class("C", "a", "b")
+>>> C("foo", "bar")
+C(a='foo', b='bar')
+```
+
+After *declaring* your attributes, *attrs* gives you:
+
+- a concise and explicit overview of the class's attributes,
+- a nice human-readable `__repr__`,
+- equality-checking methods,
+- an initializer,
+- and much more,
+
+*without* writing dull boilerplate code again and again and *without* runtime performance penalties.
+
+**Hate type annotations**!?
+No problem!
+Types are entirely **optional** with *attrs*.
+Simply assign `attrs.field()` to the attributes instead of annotating them with types.
+
+---
+
+This example uses *attrs*'s modern APIs that have been introduced in version 20.1.0, and the *attrs* package import name that has been added in version 21.3.0.
+The classic APIs (`@attr.s`, `attr.ib`, plus their serious-business aliases) and the `attr` package import name will remain **indefinitely**.
+
+Please check out *On The Core API Names*(https://www.attrs.org/en/latest/names.html) for a more in-depth explanation.
+
+
+## Data Classes
+
+On the tin, *attrs* might remind you of `dataclasses` (and indeed, `dataclasses` are a descendant(https://hynek.me/articles/import-attrs/) of *attrs*).
+In practice it does a lot more and is more flexible.
+For instance it allows you to define special handling of NumPy arrays for equality checks(https://www.attrs.org/en/stable/comparison.html#customization), or allows more ways to plug into the initialization process(https://www.attrs.org/en/stable/init.html#hooking-yourself-into-initialization).
+
+For more details, please refer to our comparison page(https://www.attrs.org/en/stable/why.html#data-classes).
+
+
+## Project Information
+
+- **Changelog**(https://www.attrs.org/en/stable/changelog.html)
+- **Documentation**(https://www.attrs.org/)
+- **PyPI**(https://pypi.org/project/attrs/)
+- **Source Code**(https://github.com/python-attrs/attrs)
+- **Contributing**(https://github.com/python-attrs/attrs/blob/main/.github/CONTRIBUTING.md)
+- **Third-party Extensions**(https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs)
+- **License**: MIT(https://www.attrs.org/en/latest/license.html)
+- **Get Help**: please use the `python-attrs` tag on StackOverflow(https://stackoverflow.com/questions/tagged/python-attrs)
+- **Supported Python Versions**: 3.6 and later
+
+
+### *attrs* for Enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of *attrs* and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
+Learn more.(https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

_service:tar_scm:attrs-22.2.0.tar.gz/changelog.d/towncrier_template.md.jinja Added

_service:tar_scm:attrs-22.1.0.tar.gz/conftest.py -> _service:tar_scm:attrs-22.2.0.tar.gz/conftest.py Changed

_service:tar_scm:attrs-22.2.0.tar.gz/docs/_static/docset-icon.png Added

_service:tar_scm:attrs-22.2.0.tar.gz/docs/_static/docset-icon@2x.png Added

_service:tar_scm:attrs-22.1.0.tar.gz/docs/api.rst -> _service:tar_scm:attrs-22.2.0.tar.gz/docs/api.rst Changed

@@ -3,18 +3,17 @@
 
 .. currentmodule:: attr
 
-``attrs`` works by decorating a class using `attrs.define` or `attr.s` and then optionally defining attributes on the class using `attrs.field`, `attr.ib`, or a type annotation.
+*attrs* works by decorating a class using `attrs.define` or `attr.s` and then optionally defining attributes on the class using `attrs.field`, `attr.ib`, or a type annotation.
 
 If you're confused by the many names, please check out `names` for clarification.
 
 What follows is the API explanation, if you'd like a more hands-on introduction, have a look at `examples`.
 
-As of version 21.3.0, ``attrs`` consists of **two** top-level package names:
+As of version 21.3.0, *attrs* consists of **two** top-level package names:
 
 - The classic ``attr`` that powered the venerable `attr.s` and `attr.ib`
 - The modern ``attrs`` that only contains most modern APIs and relies on `attrs.define` and `attrs.field` to define your classes.
   Additionally it offers some ``attr`` APIs with nicer defaults (e.g. `attrs.asdict`).
-  Using this namespace requires Python 3.6 or later.
 
 The ``attrs`` namespace is built *on top of* ``attr`` which will *never* go away.
 
@@ -29,6 +28,7 @@
   Therefore if a class, method, or function claims that it has been added in an older version, it is only available in the ``attr`` namespace.
 
 .. autodata:: attrs.NOTHING
+   :no-value:
 
 .. autofunction:: attrs.define
 
@@ -74,7 +74,7 @@
       ... class C:
       ...     x = attr.ib()
       >>> attr.fields(C).x
-      Attribute(name='x', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None)
+      Attribute(name='x', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x')
 
 
 .. autofunction:: attrs.make_class
@@ -120,11 +120,11 @@
 
    Same as `attrs.NOTHING`.
 
-.. autofunction:: attr.s(these=None, repr_ns=None, repr=None, cmp=None, hash=None, init=None, slots=False, frozen=False, weakref_slot=True, str=False, auto_attribs=False, kw_only=False, cache_hash=False, auto_exc=False, eq=None, order=None, auto_detect=False, collect_by_mro=False, getstate_setstate=None, on_setattr=None, field_transformer=None, match_args=True)
+.. autofunction:: attr.s(these=None, repr_ns=None, repr=None, cmp=None, hash=None, init=None, slots=False, frozen=False, weakref_slot=True, str=False, auto_attribs=False, kw_only=False, cache_hash=False, auto_exc=False, eq=None, order=None, auto_detect=False, collect_by_mro=False, getstate_setstate=None, on_setattr=None, field_transformer=None, match_args=True, unsafe_hash=None)
 
    .. note::
 
-      ``attrs`` also comes with a serious-business alias ``attr.attrs``.
+      *attrs* also comes with a serious-business alias ``attr.attrs``.
 
    For example:
 
@@ -164,7 +164,7 @@
 
    .. note::
 
-      ``attrs`` also comes with a serious-business alias ``attr.attrib``.
+      *attrs* also comes with a serious-business alias ``attr.attrib``.
 
    The object returned by `attr.ib` also allows for setting the default and the validator using decorators:
 
@@ -228,7 +228,7 @@
 Helpers
 -------
 
-``attrs`` comes with a bunch of helper methods that make working with it easier:
+*attrs* comes with a bunch of helper methods that make working with it easier:
 
 .. autofunction:: attrs.cmp_using
 .. function:: attr.cmp_using
@@ -246,9 +246,9 @@
       ...     x = attr.ib()
       ...     y = attr.ib()
       >>> attrs.fields(C)
-      (Attribute(name='x', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None), Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None))
+      (Attribute(name='x', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y'))
       >>> attrs.fields(C)1
-      Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None)
+      Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y')
       >>> attrs.fields(C).y is attrs.fields(C)1
       True
 
@@ -267,9 +267,9 @@
       ...     x = attr.ib()
       ...     y = attr.ib()
       >>> attrs.fields_dict(C)
-      {'x': Attribute(name='x', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None), 'y': Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None)}
+      {'x': Attribute(name='x', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='x'), 'y': Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y')}
       >>> attr.fields_dict(C)'y'
-      Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None)
+      Attribute(name='y', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=None, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='y')
       >>> attrs.fields_dict(C)'y' is attrs.fields(C).y
       True
 
@@ -357,7 +357,7 @@
 .. autofunction:: attr.astuple
 
 
-``attrs`` includes some handy helpers for filtering the attributes in `attrs.asdict` and `attrs.astuple`:
+*attrs* includes some handy helpers for filtering the attributes in `attrs.asdict` and `attrs.astuple`:
 
 .. autofunction:: attrs.filters.include
 
@@ -435,12 +435,12 @@
 .. autofunction:: get_run_validators
 
 
-.. _api_validators:
+.. _api-validators:
 
 Validators
 ----------
 
-``attrs`` comes with some common validators in the ``attrs.validators`` module.
+*attrs* comes with some common validators in the ``attrs.validators`` module.
 All objects from ``attrs.validators`` are also available from ``attr.validators``.
 
 
@@ -596,6 +596,32 @@
       x = attrs.field(validator=attrs.validators.and_(v1, v2, v3))
       x = attrs.field(validator=v1, v2, v3)
 
+.. autofunction:: attrs.validators.not_
+
+   For example:
+
+   .. doctest::
+
+      >>> reserved_names = {"id", "time", "source"}
+      >>> @attrs.define
+      ... class Measurement:
+      ...     tags = attrs.field(
+      ...         validator=attrs.validators.deep_mapping(
+      ...             key_validator=attrs.validators.not_(
+      ...                 attrs.validators.in_(reserved_names),
+      ...                 msg="reserved tag key",
+      ...             ),
+      ...             value_validator=attrs.validators.instance_of((str, int)),
+      ...         )
+      ...     )
+      >>> Measurement(tags={"source": "universe"})
+      Traceback (most recent call last):
+         ...
+      ValueError: ("reserved tag key", Attribute(name='tags', default=NOTHING, validator=<not_ validator wrapping <in_ validator with options {'id', 'time', 'source'}>, capturing (<class 'ValueError'>, <class 'TypeError'>)>, type=None, kw_only=False), <in_ validator with options {'id', 'time', 'source'}>, {'source_': 'universe'}, (<class 'ValueError'>, <class 'TypeError'>))
+      >>> Measurement(tags={"source_": "universe"})
+      Measurement(tags={'source_': 'universe'})
+
+
 .. autofunction:: attrs.validators.optional
 
    For example:

_service:tar_scm:attrs-22.2.0.tar.gz/docs/changelog.md Added

_service:tar_scm:attrs-22.2.0.tar.gz/docs/comparison.md Added

@@ -0,0 +1,63 @@
+# Comparison
+
+By default, two instances of *attrs* classes are equal if all their fields are equal.
+For that, *attrs* writes `__eq__` and `__ne__` methods for you.
+
+Additionally, if you pass `order=True`^default, *attrs* will also create a full set of ordering methods that are based on the defined fields: `__le__`, `__lt__`, `__ge__`, and `__gt__`.
+
+^default: That's the default if you use the {func}`attr.s` decorator, but not with {func}`~attrs.define`.
+
+(custom-comparison)=
+
+## Customization
+
+As with other features, you can exclude fields from being involved in comparison operations:
+
+```{doctest}
+>>> from attrs import define, field
+>>> @define
+... class C:
+...     x: int
+...     y: int = field(eq=False)
+
+>>> C(1, 2) == C(1, 3)
+True
+```
+
+Additionally you can also pass a *callable* instead of a bool to both *eq* and *order*.
+It is then used as a key function like you may know from {func}`sorted`:
+
+```{doctest}
+>>> @define
+... class S:
+...     x: str = field(eq=str.lower)
+
+>>> S("foo") == S("FOO")
+True
+
+>>> @define(order=True)
+... class C:
+...     x: str = field(order=int)
+
+>>> C("10") > C("2")
+True
+```
+
+This is especially useful when you have fields with objects that have atypical comparison properties.
+Common examples of such objects are *NumPy* arrays(https://github.com/python-attrs/attrs/issues/435).
+
+To save you unnecessary boilerplate, *attrs* comes with the {func}`attrs.cmp_using` helper to create such functions.
+For *NumPy* arrays it would look like this:
+
+```
+import numpy
+
+@define
+class C:
+   an_array = field(eq=attr.cmp_using(eq=numpy.array_equal))
+```
+
+:::{warning}
+Please note that *eq* and *order* are set *independently*, because *order* is `False` by default in {func}`~attrs.define` (but not in {func}`attr.s`).
+You can set both at once by using the *cmp* argument that we've undeprecated just for this use-case.
+:::

_service:tar_scm:attrs-22.1.0.tar.gz/docs/conf.py -> _service:tar_scm:attrs-22.2.0.tar.gz/docs/conf.py Changed

@@ -1,6 +1,12 @@
 # SPDX-License-Identifier: MIT
 
 from importlib import metadata
+from pathlib import Path
+
+
+# -- Path setup -----------------------------------------------------------
+
+PROJECT_ROOT_DIR = Path(__file__).parents1.resolve()
 
 
 # -- General configuration ------------------------------------------------
@@ -12,6 +18,8 @@
 linkcheck_ignore = 
     # We run into GitHub's rate limits.
     r"https://github.com/.*/(issues|pull)/\d+",
+    # Rate limits and the latest tag is missing anyways on release.
+    "https://github.com/python-attrs/attrs/tree/.*",
     # It never finds the anchor even though it's there.
     "https://github.com/microsoft/pyright/blob/main/specs/"
     "dataclass_transforms.md#attrs",
@@ -30,13 +38,20 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = 
+    "myst_parser",
     "sphinx.ext.autodoc",
     "sphinx.ext.doctest",
     "sphinx.ext.intersphinx",
     "sphinx.ext.todo",
     "notfound.extension",
+    "sphinxcontrib.towncrier",
 
 
+myst_enable_extensions = 
+    "colon_fence",
+    "smartquotes",
+    "deflist",
+
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = "_templates"
@@ -153,3 +168,11 @@
 
 # Allow non-local URIs so we can have images in CHANGELOG etc.
 suppress_warnings = "image.nonlocal_uri"
+
+
+# -- Options for sphinxcontrib.towncrier extension ------------------------
+
+towncrier_draft_autoversion_mode = "draft"
+towncrier_draft_include_empty = True
+towncrier_draft_working_directory = PROJECT_ROOT_DIR
+towncrier_draft_config_path = "pyproject.toml"

_service:tar_scm:attrs-22.2.0.tar.gz/docs/examples.md Added

@@ -0,0 +1,702 @@
+# *attrs* by Example
+
+## Basics
+
+The simplest possible usage is:
+
+```{doctest}
+>>> from attrs import define, field
+>>> @define
+... class Empty:
+...     pass
+>>> Empty()
+Empty()
+>>> Empty() == Empty()
+True
+>>> Empty() is Empty()
+False
+```
+
+So in other words: *attrs* is useful even without actual attributes!
+
+But you'll usually want some data on your classes, so let's add some:
+
+```{doctest}
+>>> @define
+... class Coordinates:
+...     x: int
+...     y: int
+```
+
+By default, all features are added, so you immediately have a fully functional data class with a nice `repr` string and comparison methods.
+
+```{doctest}
+>>> c1 = Coordinates(1, 2)
+>>> c1
+Coordinates(x=1, y=2)
+>>> c2 = Coordinates(x=2, y=1)
+>>> c2
+Coordinates(x=2, y=1)
+>>> c1 == c2
+False
+```
+
+As shown, the generated `__init__` method allows for both positional and keyword arguments.
+
+For private attributes, *attrs* will strip the leading underscores for keyword arguments:
+
+```{doctest}
+>>> @define
+... class C:
+...     _x: int
+>>> C(x=1)
+C(_x=1)
+```
+
+If you want to initialize your private attributes yourself, you can do that too:
+
+```{doctest}
+>>> @define
+... class C:
+...     _x: int = field(init=False, default=42)
+>>> C()
+C(_x=42)
+>>> C(23)
+Traceback (most recent call last):
+   ...
+TypeError: __init__() takes exactly 1 argument (2 given)
+```
+
+If you prefer to expose your privates, you can use keyword argument aliases:
+
+```{doctest}
+>>> @define
+... class C:
+...     _x: int = field(alias="_x")
+>>> C(_x=1)
+C(_x=1)
+```
+
+An additional way of defining attributes is supported too.
+This is useful in times when you want to enhance classes that are not yours (nice `__repr__` for Django models anyone?):
+
+```{doctest}
+>>> class SomethingFromSomeoneElse:
+...     def __init__(self, x):
+...         self.x = x
+>>> SomethingFromSomeoneElse = define(
+...     these={
+...         "x": field()
+...     }, init=False)(SomethingFromSomeoneElse)
+>>> SomethingFromSomeoneElse(1)
+SomethingFromSomeoneElse(x=1)
+```
+
+Subclassing is bad for you(https://www.youtube.com/watch?v=3MNVP9-hglc), but *attrs* will still do what you'd hope for:
+
+```{doctest}
+>>> @define(slots=False)
+... class A:
+...     a: int
+...     def get_a(self):
+...         return self.a
+>>> @define(slots=False)
+... class B:
+...     b: int
+>>> @define(slots=False)
+... class C(B, A):
+...     c: int
+>>> i = C(1, 2, 3)
+>>> i
+C(a=1, b=2, c=3)
+>>> i == C(1, 2, 3)
+True
+>>> i.get_a()
+1
+```
+
+{term}`Slotted classes <slotted classes>`, which are the default for the new APIs, don't play well with multiple inheritance so we don't use them in the example.
+
+The order of the attributes is defined by the MRO(https://www.python.org/download/releases/2.3/mro/).
+
+
+### Keyword-only Attributes
+
+You can also add keyword-only(https://docs.python.org/3/glossary.html#keyword-only-parameter) attributes:
+
+```{doctest}
+>>> @define
+... class A:
+...     a: int = field(kw_only=True)
+>>> A()
+Traceback (most recent call last):
+...
+TypeError: A() missing 1 required keyword-only argument: 'a'
+>>> A(a=1)
+A(a=1)
+```
+
+`kw_only` may also be specified at decorator level, and will apply to all attributes:
+
+```{doctest}
+>>> @define(kw_only=True)
+... class A:
+...     a: int
+...     b: int
+>>> A(1, 2)
+Traceback (most recent call last):
+...
+TypeError: __init__() takes 1 positional argument but 3 were given
+>>> A(a=1, b=2)
+A(a=1, b=2)
+```
+
+If you create an attribute with `init=False`, the `kw_only` argument is ignored.
+
+Keyword-only attributes allow subclasses to add attributes without default values, even if the base class defines attributes with default values:
+
+```{doctest}
+>>> @define
+... class A:
+...     a: int = 0
+>>> @define
+... class B(A):
+...     b: int = field(kw_only=True)
+>>> B(b=1)
+B(a=0, b=1)
+>>> B()
+Traceback (most recent call last):
+...
+TypeError: B() missing 1 required keyword-only argument: 'b'
+```
+
+If you don't set `kw_only=True`, then there is no valid attribute ordering, and you'll get an error:
+
+```{doctest}
+>>> @define
+... class A:
+...     a: int = 0
+>>> @define
+... class B(A):
+...     b: int
+Traceback (most recent call last):
+...
+ValueError: No mandatory attributes allowed after an attribute with a default value or factory.  Attribute in question: Attribute(name='b', default=NOTHING, validator=None, repr=True, cmp=True, hash=None, init=True, converter=None, metadata=mappingproxy({}), type=int, kw_only=False)
+```
+
+(asdict)=
+
+## Converting to Collections Types
+
+When you have a class with data, it often is very convenient to transform that class into a {class}`dict` (for example if you want to serialize it to JSON):
+
+```{doctest}
+>>> from attrs import asdict
+>>> asdict(Coordinates(x=1, y=2))
+{'x': 1, 'y': 2}
+```
+
+Some fields cannot or should not be transformed.

_service:tar_scm:attrs-22.2.0.tar.gz/docs/extending.md Added

@@ -0,0 +1,336 @@
+# Extending
+
+Each *attrs*-decorated class has a `__attrs_attrs__` class attribute.
+It's a tuple of {class}`attrs.Attribute` carrying metadata about each attribute.
+
+So it is fairly simple to build your own decorators on top of *attrs*:
+
+```{doctest}
+>>> from attr import define
+>>> def print_attrs(cls):
+...     print(cls.__attrs_attrs__)
+...     return cls
+>>> @print_attrs
+... @define
+... class C:
+...     a: int
+(Attribute(name='a', default=NOTHING, validator=None, repr=True, eq=True, eq_key=None, order=True, order_key=None, hash=None, init=True, metadata=mappingproxy({}), type=<class 'int'>, converter=None, kw_only=False, inherited=False, on_setattr=None, alias='a'),)
+```
+
+:::{warning}
+The {func}`attrs.define` / {func}`attr.s` decorator **must** be applied first because it puts `__attrs_attrs__` in place!
+That means that is has to come *after* your decorator because:
+
+```python
+@a
+@b
+def f():
+   pass
+```
+
+is just syntactic sugar(https://en.wikipedia.org/wiki/Syntactic_sugar) for:
+
+```python
+def original_f():
+   pass
+
+f = a(b(original_f))
+```
+:::
+
+
+## Wrapping the Decorator
+
+A more elegant way can be to wrap *attrs* altogether and build a class DSL(https://en.wikipedia.org/wiki/Domain-specific_language) on top of it.
+
+An example for that is the package *environ-config*(https://github.com/hynek/environ-config) that uses *attrs* under the hood to define environment-based configurations declaratively without exposing *attrs* APIs at all.
+
+Another common use case is to overwrite *attrs*'s defaults.
+
+
+### 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:
+
+```python
+from mypy.plugin import Plugin
+from mypy.plugins.attrs import (
+   attr_attrib_makers,
+   attr_class_makers,
+   attr_dataclass_makers,
+)
+
+# These work just like `attr.dataclass`.
+attr_dataclass_makers.add("my_module.method_looks_like_attr_dataclass")
+
+# This works just like `attr.s`.
+attr_class_makers.add("my_module.method_looks_like_attr_s")
+
+# These are our `attr.ib` makers.
+attr_attrib_makers.add("my_module.method_looks_like_attrib")
+
+class MyPlugin(Plugin):
+    # Our plugin does nothing but it has to exist so this file gets loaded.
+    pass
+
+
+def plugin(version):
+    return MyPlugin
+```
+
+Then tell *Mypy* about your plugin using your project's `mypy.ini`:
+
+```ini
+mypy
+plugins=<path to file>
+```
+
+:::{warning}
+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*(https://github.com/microsoft/pyright) via their `dataclass_transform` specification.
+
+For a custom wrapping of the form:
+
+```
+def custom_define(f):
+    return attr.define(f)
+```
+
+This is implemented via a `__dataclass_transform__` type decorator in the custom extension's `.pyi` of the form:
+
+```
+def __dataclass_transform__(
+    *,
+    eq_default: bool = True,
+    order_default: bool = False,
+    kw_only_default: bool = False,
+    field_descriptors: TupleUniontype, Callable..., Any, ... = (()),
+) -> Callable_T, _T: ...
+
+@__dataclass_transform__(field_descriptors=(attr.attrib, attr.field))
+def custom_define(f): ...
+```
+
+:::{warning}
+`dataclass_transform` is supported **provisionally** as of `pyright` 1.1.135.
+
+Both the *Pyright* `dataclass_transform` specification and *attrs* implementation may change in future versions.
+:::
+
+## Types
+
+*attrs* offers two ways of attaching type information to attributes:
+
+- {pep}`526` annotations,
+- and the *type* argument to {func}`attr.ib`.
+
+This information is available to you:
+
+```{doctest}
+>>> from attr import attrib, define, field, fields
+>>> @define
+... class C:
+...     x: int = field()
+...     y = attrib(type=str)
+>>> fields(C).x.type
+<class 'int'>
+>>> fields(C).y.type
+<class 'str'>
+```
+
+Currently, *attrs* doesn't do anything with this information but it's very useful if you'd like to write your own validators or serializers!
+
+(extending-metadata)=
+
+## Metadata
+
+If you're the author of a third-party library with *attrs* integration, you may want to take advantage of attribute metadata.
+
+Here are some tips for effective use of metadata:
+
+- Try making your metadata keys and values immutable.
+  This keeps the entire {class}`~attrs.Attribute` instances immutable too.
+
+- To avoid metadata key collisions, consider exposing your metadata keys from your modules.:
+
+  ```python
+  from mylib import MY_METADATA_KEY
+
+  @define
+  class C:
+    x = field(metadata={MY_METADATA_KEY: 1})
+  ```
+
+  Metadata should be composable, so consider supporting this approach even if you decide implementing your metadata in one of the following ways.
+
+- Expose `field` wrappers for your specific metadata.
+  This is a more graceful approach if your users don't require metadata from other libraries.
+
+  ```{doctest}
+  >>> from attrs import fields, NOTHING
+  >>> MY_TYPE_METADATA = '__my_type_metadata'
+  >>>
+  >>> def typed(
+  ...     cls, default=NOTHING, validator=None, repr=True,
+  ...     eq=True, order=None, hash=None, init=True, metadata=None,
+  ...     converter=None
+  ... ):
+  ...     metadata = metadata or {}
+  ...     metadataMY_TYPE_METADATA = cls
+  ...     return field(
+  ...         default=default, validator=validator, repr=repr,
+  ...         eq=eq, order=order, hash=hash, init=init,
+  ...         metadata=metadata, converter=converter
+  ...     )
+  >>>
+  >>> @define
+  ... class C:
+  ...     x: int = typed(int, default=1, init=False)
+  >>> fields(C).x.metadataMY_TYPE_METADATA
+  <class 'int'>
+  ```
+

_service:tar_scm:attrs-22.2.0.tar.gz/docs/glossary.md Added

@@ -0,0 +1,104 @@
+# Glossary
+
+:::{glossary}
+dunder methods
+  "Dunder" is a contraction of "double underscore".
+
+  It's methods like `__init__` or `__eq__` that are sometimes also called *magic methods* or it's said that they implement an *object protocol*.
+
+  In spoken form, you'd call `__init__` just "dunder init".
+
+  Its first documented use is a mailing list posting(https://mail.python.org/pipermail/python-list/2002-September/155836.html) by Mark Jackson from 2002.
+
+dict classes
+  A regular class whose attributes are stored in the {attr}`object.__dict__` attribute of every single instance.
+  This is quite wasteful especially for objects with very few data attributes and the space consumption can become significant when creating large numbers of instances.
+
+  This is the type of class you get by default both with and without *attrs* (except with the next APIs {func}`attrs.define()`, `attrs.mutable()`(attrs.mutable), and `attrs.frozen()`(attrs.frozen)).
+
+slotted classes
+  A class whose instances have no {attr}`object.__dict__` attribute and define(https://docs.python.org/3/reference/datamodel.html#slots) their attributes in a `object.__slots__` attribute instead.
+  In *attrs*, they are created by passing `slots=True` to `@attr.s` (and are on by default in {func}`attrs.define()`, `attrs.mutable()`(attrs.mutable), and `attrs.frozen()`(attrs.frozen)).
+
+  Their main advantage is that they use less memory on CPython^pypy and are slightly faster.
+
+  However, they also come with several possibly surprising gotchas:
+
+  - Slotted classes don't allow for any other attribute to be set except for those defined in one of the class' hierarchies `__slots__`:
+
+    ```{doctest}
+    >>> from attr import define
+    >>> @define
+    ... class Coordinates:
+    ...     x: int
+    ...     y: int
+    ...
+    >>> c = Coordinates(x=1, y=2)
+    >>> c.z = 3
+    Traceback (most recent call last):
+        ...
+    AttributeError: 'Coordinates' object has no attribute 'z'
+    ```
+
+  - Slotted classes can inherit from other classes just like non-slotted classes, but some of the benefits of slotted classes are lost if you do that.
+    If you must inherit from other classes, try to inherit only from other slotted classes.
+
+  - However, it's not possible(https://docs.python.org/3/reference/datamodel.html#notes-on-using-slots) to inherit from more than one class that has attributes in `__slots__` (you will get an `TypeError: multiple bases have instance lay-out conflict`).
+
+  - It's not possible to monkeypatch methods on slotted classes.
+    This can feel limiting in test code, however the need to monkeypatch your own classes is usually a design smell.
+
+    If you really need to monkeypatch an instance in your tests, but don't want to give up on the advantages of slotted classes in production code, you can always subclass a slotted class as a dict class with no further changes and all the limitations go away:
+
+    ```{doctest}
+    >>> import unittest.mock
+    >>> @define
+    ... class Slotted:
+    ...     x: int
+    ...
+    ...     def method(self):
+    ...         return self.x
+    >>> s = Slotted(42)
+    >>> s.method()
+    42
+    >>> with unittest.mock.patch.object(s, "method", return_value=23):
+    ...     pass
+    Traceback (most recent call last):
+      ...
+    AttributeError: 'Slotted' object attribute 'method' is read-only
+    >>> @define(slots=False)
+    ... class Dicted(Slotted):
+    ...     pass
+    >>> d = Dicted(42)
+    >>> d.method()
+    42
+    >>> with unittest.mock.patch.object(d, "method", return_value=23):
+    ...     assert 23 == d.method()
+    ```
+
+  - Slotted classes must implement {meth}`__getstate__ <object.__getstate__>` and {meth}`__setstate__ <object.__setstate__>` to be serializable with {mod}`pickle` protocol 0 and 1.
+    Therefore, *attrs* creates these methods automatically for slotted classes.
+
+    :::{note}
+    When decorating with `@attr.s(slots=True)` and the class already implements the {meth}`__getstate__ <object.__getstate__>` and {meth}`__setstate__ <object.__setstate__>` methods, they will be *overwritten* by *attrs* autogenerated implementation by default.
+
+    This can be avoided by setting `@attr.s(getstate_setstate=False)` or by setting `@attr.s(auto_detect=True)`.
+
+    {func}`~attrs.define` sets `auto_detect=True` by default.
+    :::
+
+    Also, think twice(https://www.youtube.com/watch?v=7KnfGDajDQw) before using {mod}`pickle`.
+
+  - Slotted classes are weak-referenceable by default.
+    This can be disabled in CPython by passing `weakref_slot=False` to `@attr.s` ^pypyweakref.
+
+  - Since it's currently impossible to make a class slotted after it's been created, *attrs* has to replace your class with a new one.
+    While it tries to do that as graciously as possible, certain metaclass features like {meth}`object.__init_subclass__` do not work with slotted classes.
+
+  - The {attr}`class.__subclasses__` attribute needs a garbage collection run (which can be manually triggered using {func}`gc.collect`), for the original class to be removed.
+    See issue #407(https://github.com/python-attrs/attrs/issues/407) for more details.
+:::
+
+^pypy: On PyPy, there is no memory advantage in using slotted classes.
+
+^pypyweakref: On PyPy, slotted classes are naturally weak-referenceable so `weakref_slot=False` has no effect.

_service:tar_scm:attrs-22.2.0.tar.gz/docs/hashing.md Added

@@ -0,0 +1,85 @@
+# Hashing
+
+## Hash Method Generation
+
+:::{warning}
+The overarching theme is to never set the `@attrs.define(unsafe_hash=X)` parameter yourself.
+Leave it at `None` which means that *attrs* will do the right thing for you, depending on the other parameters:
+
+- If you want to make objects hashable by value: use `@define(frozen=True)`.
+- If you want hashing and equality by object identity: use `@define(eq=False)`
+
+Setting `unsafe_hash` yourself can have unexpected consequences so we recommend to tinker with it only if you know exactly what you're doing.
+:::
+
+Under certain circumstances, it's necessary for objects to be *hashable*.
+For example if you want to put them into a {class}`set` or if you want to use them as keys in a {class}`dict`.
+
+The *hash* of an object is an integer that represents the contents of an object.
+It can be obtained by calling {func}`hash` on an object and is implemented by writing a `__hash__` method for your class.
+
+*attrs* will happily write a `__hash__` method for you ^fn1, however it will *not* do so by default.
+Because according to the definition(https://docs.python.org/3/glossary.html#term-hashable) from the official Python docs, the returned hash has to fulfill certain constraints:
+
+^fn1: The hash is computed by hashing a tuple that consists of a unique id for the class plus all attribute values.
+
+1. Two objects that are equal, **must** have the same hash.
+   This means that if `x == y`, it *must* follow that `hash(x) == hash(y)`.
+
+   By default, Python classes are compared *and* hashed by their `id`.
+   That means that every instance of a class has a different hash, no matter what attributes it carries.
+
+   It follows that the moment you (or *attrs*) change the way equality is handled by implementing `__eq__` which is based on attribute values, this constraint is broken.
+   For that reason Python 3 will make a class that has customized equality unhashable.
+   Python 2 on the other hand will happily let you shoot your foot off.
+   Unfortunately, *attrs* still mimics (otherwise unsupported) Python 2's behavior for backward-compatibility reasons if you set `unsafe_hash=False`.
+
+   The *correct way* to achieve hashing by id is to set `@define(eq=False)`.
+   Setting `@define(unsafe_hash=False)` (which implies `eq=True`) is almost certainly a *bug*.
+
+   :::{warning}
+   Be careful when subclassing!
+   Setting `eq=False` on a class whose base class has a non-default `__hash__` method will *not* make *attrs* remove that `__hash__` for you.
+
+   It is part of *attrs*'s philosophy to only *add* to classes so you have the freedom to customize your classes as you wish.
+   So if you want to *get rid* of methods, you'll have to do it by hand.
+
+   The easiest way to reset `__hash__` on a class is adding `__hash__ = object.__hash__` in the class body.
+   :::
+
+2. If two objects are not equal, their hash **should** be different.
+
+   While this isn't a requirement from a standpoint of correctness, sets and dicts become less effective if there are a lot of identical hashes.
+   The worst case is when all objects have the same hash which turns a set into a list.
+
+3. The hash of an object **must not** change.
+
+   If you create a class with `@define(frozen=True)` this is fulfilled by definition, therefore *attrs* will write a `__hash__` function for you automatically.
+   You can also force it to write one with `unsafe_hash=True` but then it's *your* responsibility to make sure that the object is not mutated.
+
+   This point is the reason why mutable structures like lists, dictionaries, or sets aren't hashable while immutable ones like tuples or `frozenset`s are:
+   point 1 and 2 require that the hash changes with the contents but point 3 forbids it.
+
+For a more thorough explanation of this topic, please refer to this blog post: *Python Hashes and Equality*(https://hynek.me/articles/hashes-and-equality/).
+
+:::{note}
+Please note that the `unsafe_hash` argument's original name was `hash` but was changed to conform with {pep}`681` in 22.2.0.
+The old argument name is still around and will **not** be removed -- but setting `unsafe_hash` takes precedence over `hash`.
+The field-level argument is still called `hash` and will remain so.
+:::
+
+
+## Hashing and Mutability
+
+Changing any field involved in hash code computation after the first call to `__hash__` (typically this would be after its insertion into a hash-based collection) can result in silent bugs.
+Therefore, it is strongly recommended that hashable classes be `frozen`.
+Beware, however, that this is not a complete guarantee of safety:
+if a field points to an object and that object is mutated, the hash code may change, but `frozen` will not protect you.
+
+
+## Hash Code Caching
+
+Some objects have hash codes which are expensive to compute.
+If such objects are to be stored in hash-based collections, it can be useful to compute the hash codes only once and then store the result on the object to make future hash code requests fast.
+To enable caching of hash codes, pass `@define(cache_hash=True)`.
+This may only be done if *attrs* is already generating a hash function for the object.

_service:tar_scm:attrs-22.2.0.tar.gz/docs/how-does-it-work.md Added

@@ -0,0 +1,98 @@
+(how)=
+
+# How Does It Work?
+
+## Boilerplate
+
+*attrs* isn't the first library that aims to simplify class definition in Python.
+But its **declarative** approach combined with **no runtime overhead** lets it stand out.
+
+Once you apply the `@attrs.define` (or `@attr.s`) decorator to a class, *attrs* searches the class object for instances of `attr.ib`s.
+Internally they're a representation of the data passed into `attr.ib` along with a counter to preserve the order of the attributes.
+Alternatively, it's possible to define them using {doc}`types`.
+
+In order to ensure that subclassing works as you'd expect it to work, *attrs* also walks the class hierarchy and collects the attributes of all base classes.
+Please note that *attrs* does *not* call `super()` *ever*.
+It will write {term}`dunder methods` to work on *all* of those attributes which also has performance benefits due to fewer function calls.
+
+Once *attrs* knows what attributes it has to work on, it writes the requested {term}`dunder methods` and -- depending on whether you wish to have a {term}`dict <dict classes>` or {term}`slotted <slotted classes>` class -- creates a new class for you (`slots=True`) or attaches them to the original class (`slots=False`).
+While creating new classes is more elegant, we've run into several edge cases surrounding metaclasses that make it impossible to go this route unconditionally.
+
+To be very clear: if you define a class with a single attribute without a default value, the generated `__init__` will look *exactly* how you'd expect:
+
+```{doctest}
+>>> import inspect
+>>> from attrs import define
+>>> @define
+... class C:
+...     x: int
+>>> print(inspect.getsource(C.__init__))
+def __init__(self, x):
+    self.x = x
+<BLANKLINE>
+```
+
+No magic, no meta programming, no expensive introspection at runtime.
+
+---
+
+Everything until this point happens exactly *once* when the class is defined.
+As soon as a class is done, it's done.
+And it's just a regular Python class like any other, except for a single `__attrs_attrs__` attribute that *attrs* uses internally.
+Much of the information is accessible via {func}`attrs.fields` and other functions which can be used for introspection or for writing your own tools and decorators on top of *attrs* (like {func}`attrs.asdict`).
+
+And once you start instantiating your classes, *attrs* is out of your way completely.
+
+This **static** approach was very much a design goal of *attrs* and what I strongly believe makes it distinct.
+
+(how-frozen)=
+
+## Immutability
+
+In order to give you immutability, *attrs* will attach a `__setattr__` method to your class that raises an {class}`attrs.exceptions.FrozenInstanceError` whenever anyone tries to set an attribute.
+
+The same is true if you choose to freeze individual attributes using the {obj}`attrs.setters.frozen` *on_setattr* hook -- except that the exception becomes {class}`attrs.exceptions.FrozenAttributeError`.
+
+Both exceptions subclass {class}`attrs.exceptions.FrozenError`.
+
+---
+
+Depending on whether a class is a dict class or a slotted class, *attrs* uses a different technique to circumvent that limitation in the `__init__` method.
+
+Once constructed, frozen instances don't differ in any way from regular ones except that you cannot change its attributes.
+
+### Dict Classes
+
+Dict classes -- i.e. regular classes -- simply assign the value directly into the class' eponymous `__dict__` (and there's nothing we can do to stop the user to do the same).
+
+The performance impact is negligible.
+
+### Slotted Classes
+
+Slotted classes are more complicated.
+Here it uses (an aggressively cached) {meth}`object.__setattr__` to set your attributes.
+This is (still) slower than a plain assignment:
+
+```none
+$ pyperf timeit --rigorous \
+      -s "import attr; C = attr.make_class('C', 'x', 'y', 'z', slots=True)" \
+      "C(1, 2, 3)"
+.........................................
+Mean +- std dev: 228 ns +- 18 ns
+
+$ pyperf timeit --rigorous \
+      -s "import attr; C = attr.make_class('C', 'x', 'y', 'z', slots=True, frozen=True)" \
+      "C(1, 2, 3)"
+.........................................
+Mean +- std dev: 425 ns +- 16 ns
+```
+
+So on a laptop computer the difference is about 200 nanoseconds (1 second is 1,000,000,000 nanoseconds).
+It's certainly something you'll feel in a hot loop but shouldn't matter in normal code.
+Pick what's more important to you.
+
+### Summary
+
+You should avoid instantiating lots of frozen slotted classes (i.e. `@frozen`) in performance-critical code.
+
+Frozen dict classes have barely a performance impact, unfrozen slotted classes are even *faster* than unfrozen dict classes (i.e. regular classes).

_service:tar_scm:attrs-22.2.0.tar.gz/docs/index.md Added

@@ -0,0 +1,83 @@
+# *attrs*: Classes Without Boilerplate
+
+Release **{sub-ref}`release`**  (What's new?(changelog.md))
+
+```{include} ../README.md
+:start-after: 'teaser-begin -->'
+:end-before: '<!-- teaser-end'
+```
+
+
+## Getting Started
+
+*attrs* is a Python-only package hosted on PyPI(https://pypi.org/project/attrs/).
+The recommended installation method is pip(https://pip.pypa.io/en/stable/)-installing into a virtualenv(https://hynek.me/articles/virtualenv-lives/):
+
+```console
+$ python -m pip install attrs
+```
+
+The next steps will get you up and running in no time:
+
+- {doc}`overview` will show you a simple example of *attrs* in action and introduce you to its philosophy.
+  Afterwards, you can start writing your own classes and understand what drives *attrs*'s design.
+- {doc}`examples` will give you a comprehensive tour of *attrs*'s features.
+  After reading, you will know about our advanced features and how to use them.
+- {doc}`why` gives you a rundown of potential alternatives and why we think *attrs* is still worthwhile -- depending on *your* needs even superior.
+- If at any point you get confused by some terminology, please check out our {doc}`glossary`.
+
+If you need any help while getting started, feel free to use the `python-attrs` tag on Stack Overflow(https://stackoverflow.com/questions/tagged/python-attrs) and someone will surely help you out!
+
+
+## Day-to-Day Usage
+
+- {doc}`types` help you to write *correct* and *self-documenting* code.
+  *attrs* has first class support for them, yet keeps them optional if you’re not convinced!
+- Instance initialization is one of *attrs* key feature areas.
+  Our goal is to relieve you from writing as much code as possible.
+  {doc}`init` gives you an overview what *attrs* has to offer and explains some related philosophies we believe in.
+- Comparing and ordering objects is a common task.
+  {doc}`comparison` shows you how *attrs* helps you with that and how you can customize it.
+- If you want to put objects into sets or use them as keys in dictionaries, they have to be hashable.
+  The simplest way to do that is to use frozen classes, but the topic is more complex than it seems and {doc}`hashing` will give you a primer on what to look out for.
+- Once you're comfortable with the concepts, our {doc}`api` contains all information you need to use *attrs* to its fullest.
+- *attrs* is built for extension from the ground up.
+  {doc}`extending` will show you the affordances it offers and how to make it a building block of your own projects.
+- Finally, if you're confused by all the `attr.s`, `attr.ib`, `attrs`, `attrib`, `define`, `frozen`, and `field`, head over to {doc}`names` for a very short explanation, and optionally a quick history lesson.
+
+
+## Project Information
+
+```{include} ../README.md
+:start-after: '## Project Information'
+```
+
+---
+
+## Full Table of Contents
+
+```{toctree}
+:maxdepth: 2
+
+overview
+why
+examples
+types
+init
+comparison
+hashing
+api
+extending
+how-does-it-work
+names
+glossary
+```
+
+```{toctree}
+:maxdepth: 1
+
+license
+changelog
+```
+
+Full Index(genindex)

_service:tar_scm:attrs-22.2.0.tar.gz/docs/init.md Added

@@ -0,0 +1,508 @@
+# Initialization
+
+In Python, instance initialization happens in the `__init__` method.
+Generally speaking, you should keep as little logic as possible in it, and you should think about what the class needs and not how it is going to be instantiated.
+
+Passing complex objects into `__init__` and then using them to derive data for the class unnecessarily couples your new class with the old class which makes it harder to test and also will cause problems later.
+
+So assuming you use an ORM and want to extract 2D points from a row object, do not write code like this:
+
+```python
+class Point:
+    def __init__(self, database_row):
+        self.x = database_row.x
+        self.y = database_row.y
+
+pt = Point(row)
+```
+
+Instead, write a {obj}`classmethod` that will extract it for you:
+
+```python
+@define
+class Point:
+    x: float
+    y: float
+
+    @classmethod
+    def from_row(cls, row):
+        return cls(row.x, row.y)
+
+pt = Point.from_row(row)
+```
+
+Now you can instantiate `Point`s without creating fake row objects in your tests and you can have as many smart creation helpers as you want, in case more data sources appear.
+
+For similar reasons, we strongly discourage from patterns like:
+
+```python
+pt = Point(**row.attributes)
+```
+
+which couples your classes to the database data model.
+Try to design your classes in a way that is clean and convenient to use -- not based on your database format.
+The database format can change anytime and you're stuck with a bad class design that is hard to change.
+Embrace functions and classmethods as a filter between reality and what's best for you to work with.
+
+:::{warning}
+While *attrs*'s initialization concepts (including the following sections about validators and converters) are powerful, they are **not** intended to replace a fully-featured serialization or validation system.
+
+We want to help you to write a `__init__` that you'd write by hand, but with less boilerplate.
+
+If you look for powerful-yet-unintrusive serialization and validation for your *attrs* classes, have a look at our sibling project *cattrs*(https://catt.rs/) or our third-party extensions(https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs).
+:::
+
+(private-attributes)=
+
+## Private Attributes and Aliases
+
+One thing people tend to find confusing is the treatment of private attributes that start with an underscore.
+*attrs* follows the doctrine that there is no such thing as a private argument(https://github.com/hynek/characteristic/issues/6) and strips the underscores from the name when writing the `__init__` method signature:
+
+```{doctest}
+>>> import inspect
+>>> from attrs import define
+>>> @define
+... class C:
+...    _x: int
+>>> inspect.signature(C.__init__)
+<Signature (self, x: int) -> None>
+```
+
+There really isn't a right or wrong, it's a matter of taste.
+But it's important to be aware of it because it can lead to surprising syntax errors:
+
+```{doctest}
+>>> @define
+... class C:
+...    _1: int
+Traceback (most recent call last):
+   ...
+SyntaxError: invalid syntax
+```
+
+In this case a valid attribute name `_1` got transformed into an invalid argument name `1`.
+
+If your taste differs, you can use the *alias* argument to {func}`attrs.field` to explicitly set the argument name.
+This can be used to override private attribute handling, or make other arbitrary changes to `__init__` argument names.
+
+```{doctest}
+>>> from attrs import field
+>>> @define
+... class C:
+...    _x: int = field(alias="_x")
+...    y: int = field(alias="distasteful_y")
+>>> inspect.signature(C.__init__)
+<Signature (self, _x: int, distasteful_y: int) -> None>
+```
+
+
+## Defaults
+
+Sometimes you don't want to pass all attribute values to a class.
+And sometimes, certain attributes aren't even intended to be passed but you want to allow for customization anyways for easier testing.
+
+This is when default values come into play:
+
+```{doctest}
+>>> from attrs import Factory
+>>> @define
+... class C:
+...     a: int = 42
+...     b: list = field(factory=list)
+...     c: list = Factory(list)  # syntactic sugar for above
+...     d: dict = field()
+...     @d.default
+...     def _any_name_except_a_name_of_an_attribute(self):
+...        return {}
+>>> C()
+C(a=42, b=, c=, d={})
+```
+
+It's important that the decorated method -- or any other method or property! -- doesn't have the same name as the attribute, otherwise it would overwrite the attribute definition.
+
+Please note that as with function and method signatures, `default=` will *not* do what you may think it might do:
+
+```{doctest}
+>>> @define
+... class C:
+...     x = 
+>>> i = C()
+>>> k = C()
+>>> i.x.append(42)
+>>> k.x
+42
+```
+
+This is why *attrs* comes with factory options.
+
+:::{warning}
+Please note that the decorator based defaults have one gotcha:
+they are executed when the attribute is set, that means depending on the order of attributes, the `self` object may not be fully initialized when they're called.
+
+Therefore you should use `self` as little as possible.
+
+Even the smartest of us can get confused(https://github.com/python-attrs/attrs/issues/289) by what happens if you pass partially initialized objects around.
+:::
+
+(validators)=
+
+## Validators
+
+Another thing that definitely *does* belong in `__init__` is checking the resulting instance for invariants.
+This is why *attrs* has the concept of validators.
+
+
+### Decorator
+
+The most straightforward way is using the attribute's `validator` method as a decorator.
+
+The method has to accept three arguments:
+
+1. the *instance* that's being validated (aka `self`),
+2. the *attribute* that it's validating, and finally
+3. the *value* that is passed for it.
+
+These values are passed as *positional arguments*, therefore their names don't matter.
+
+If the value does not pass the validator's standards, it just raises an appropriate exception.
+
+```{doctest}
+>>> @define
+... class C:
+...     x: int = field()
+...     @x.validator
+...     def _check_x(self, attribute, value):
+...         if value > 42:
+...             raise ValueError("x must be smaller or equal to 42")
+>>> C(42)
+C(x=42)
+>>> C(43)
+Traceback (most recent call last):
+   ...
+ValueError: x must be smaller or equal to 42
+```
+
+Again, it's important that the decorated method doesn't have the same name as the attribute and that the {func}`attrs.field` helper is used.
+
+
+### Callables
+
+If you want to re-use your validators, you should have a look at the `validator` argument to {func}`attrs.field`.
+
+It takes either a callable or a list of callables (usually functions) and treats them as validators that receive the same arguments as with the decorator approach.
+Also as with the decorator approach, they are passed as *positional arguments* so you can name them however you want.
+
+Since the validators run *after* the instance is initialized, you can refer to other attributes while validating:
+
+```{doctest}
+>>> import attrs

_service:tar_scm:attrs-22.2.0.tar.gz/docs/license.md Added

@@ -0,0 +1,13 @@
+# License and Credits
+
+*attrs* is licensed under the MIT(https://choosealicense.com/licenses/mit/) license.
+The full license text can be also found in the source code repository(https://github.com/python-attrs/attrs/blob/main/LICENSE).
+
+*attrs* is written and maintained by Hynek Schlawack(https://hynek.me/).
+
+The development is kindly supported by my employer Variomedia AG(https://www.variomedia.de/), *attrs* Tidelift subscribers(https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo),  and all my amazing GitHub Sponsors(https://github.com/sponsors/hynek).
+
+A full list of contributors can be found in GitHub's overview(https://github.com/python-attrs/attrs/graphs/contributors).
+
+It’s the spiritual successor of characteristic(https://characteristic.readthedocs.io/) and aspires to fix some of it clunkiness and unfortunate decisions.
+Both were inspired by Twisted’s FancyEqMixin(https://docs.twisted.org/en/stable/api/twisted.python.util.FancyEqMixin.html) but both are implemented using class decorators because subclassing is bad for you(https://www.youtube.com/watch?v=3MNVP9-hglc), m’kay?

_service:tar_scm:attrs-22.2.0.tar.gz/docs/names.md Added

@@ -0,0 +1,121 @@
+# On The Core API Names
+
+You may be surprised seeing *attrs* classes being created using {func}`attrs.define` and with type annotated fields, instead of {func}`attr.s` and {func}`attr.ib()`.
+
+Or, you wonder why the web and talks are full of this weird `attr.s` and `attr.ib` -- including people having strong opinions about it and using `attr.attrs` and `attr.attrib` instead.
+
+And what even is `attr.dataclass` that's not documented but commonly used!?
+
+
+## TL;DR
+
+We recommend our modern APIs for new code:
+
+% {func} syntax does currently not work for `.. function` definitions.
+
+- {func}`attrs.define` to define a new class,
+- `attrs.mutable()`(attrs.mutable) is an alias for {func}`attrs.define`,
+- `attrs.frozen()`(attrs.frozen) is an alias for `define(frozen=True)`
+- and {func}`attrs.field()` to define an attribute.
+
+They have been added in *attrs* 20.1.0, they are expressive, and they have modern defaults like slots and type annotation awareness switched on by default.
+Sometimes they're referred to as *next-generation* or *NG* APIs.
+As of *attrs* 21.3.0 you can also import them from the `attrs` package namespace.
+
+The traditional APIs {func}`attr.s` / {func}`attr.ib`, their serious-business aliases `attr.attrs` / `attr.attrib`, and the never-documented, but popular `attr.dataclass` easter egg will stay **forever**.
+
+*attrs* will **never** force you to use type annotations.
+
+
+## A Short History Lesson
+
+At this point, *attrs* is an old project.
+It had its first release in April 2015 -- back when most Python code was on Python 2.7 and Python 3.4 was the first Python 3 release that showed promise.
+*attrs* was always Python 3-first, but type annotations(https://peps.python.org/pep-0484/) came only into Python 3.5 that was released in September 2015 and were largely ignored until years later.
+
+At this time, if you didn't want to implement all the {term}`dunder methods`, the most common way to create a class with some attributes on it was to subclass a {obj}`collections.namedtuple`, or one of the many hacks that allowed you to access dictionary keys using attribute lookup.
+
+But *attrs* history goes even a bit further back, to the now-forgotten *characteristic*(https://github.com/hynek/characteristic) that came out in May 2014 and already used a class decorator, but was overall too unergonomic.
+
+In the wake of all of that, Glyph(https://github.com/glyph) and Hynek(https://github.com/hynek) came together on IRC and brainstormed how to take the good ideas of *characteristic*, but make them easier to use and read.
+At this point the plan was not to make *attrs* what it is now -- a flexible class-building kit.
+All we wanted was an ergonomic little library to succinctly define classes with attributes.
+
+Under the impression of the unwieldy `characteristic` name, we went to the other side and decided to make the package name part of the API, and keep the API functions very short.
+This led to the infamous {func}`attr.s` and {func}`attr.ib` which some found confusing and pronounced it as "attr dot s" or used a singular `@s` as the decorator.
+But it was really just a way to say `attrs` and `attrib`^attr.
+
+^attr: We considered calling the PyPI package just `attr` too, but the name was already taken by an *ostensibly* inactive package on PyPI(https://pypi.org/project/attr/#history).
+
+Some people hated this cutey API from day one, which is why we added aliases for them that we called *serious business*: `@attr.attrs` and `attr.attrib()`.
+Fans of them usually imported the names and didn't use the package name in the first place.
+Unfortunately, the `attr` package name started creaking the moment we added `attr.Factory`, since it couldn’t be morphed into something meaningful in any way.
+A problem that grew worse over time, as more APIs and even modules were added.
+
+But overall, *attrs* in this shape was a **huge** success -- especially after Glyph's blog post *The One Python Library Everyone Needs*(https://glyph.twistedmatrix.com/2016/08/attrs.html) in August 2016 and *pytest*(https://docs.pytest.org/) adopting it.
+
+Being able to just write:
+
+```
+@attr.s
+class Point:
+    x = attr.ib()
+    y = attr.ib()
+```
+
+was a big step for those who wanted to write small, focused classes.
+
+### Dataclasses Enter The Arena
+
+A big change happened in May 2017 when Hynek sat down with Guido van Rossum(https://en.wikipedia.org/wiki/Guido_van_Rossum) and Eric V. Smith(https://github.com/ericvsmith) at PyCon US 2017.
+
+Type annotations for class attributes have just landed(https://peps.python.org/pep-0526/) in Python 3.6 and Guido felt like it would be a good mechanic to introduce something similar to *attrs* to the Python standard library.
+The result, of course, was {pep}`557`^stdlib which eventually became the `dataclasses` module in Python 3.7.
+
+^stdlib: The highly readable PEP also explains why *attrs* wasn't just added to the standard library.
+    Don't believe the myths and rumors.
+
+*attrs* at this point was lucky to have several people on board who were also very excited about type annotations and helped implement it; including a Mypy plugin(https://medium.com/@Pilot-EPD-Blog/mypy-and-attrs-e1b0225e9ac6).
+And so it happened that *attrs* shipped(https://www.attrs.org/en/17.3.0.post2/changelog.html) the new method of defining classes more than half a year before Python 3.7 -- and thus `dataclasses` -- were released.
+
+---
+
+Due to backwards-compatibility concerns, this feature is off by default in the {func}`attr.s` decorator and has to be activated using `@attr.s(auto_attribs=True)`, though.
+As a little easter egg and to save ourselves some typing, we've also added(https://github.com/python-attrs/attrs/commit/88aa1c897dfe2ee4aa987e4a56f2ba1344a17238#diff-4fc63db1f2fcb7c6e464ee9a77c3c74e90dd191d1c9ffc3bdd1234d3a6663dc0R48) an alias called `attr.dataclasses` that just set `auto_attribs=True`.
+It was never documented, but people found it and used it and loved it.
+
+Over the next months and years it became clear that type annotations have become the popular way to define classes and their attributes.
+However, it has also become clear that some people viscerally hate type annotations.
+We're determined to serve both.
+
+
+### *attrs* TNG
+
+Over its existence, *attrs* never stood still.
+But since we also greatly care about backwards-compatibility and not breaking our users' code, many features and niceties have to be manually activated.
+
+That is not only annoying, it also leads to the problem that many of *attrs*'s users don't even know what it can do for them.
+We've spent years alone explaining that defining attributes using type annotations is in no way unique to {mod}`dataclasses`.
+
+Finally we've decided to take the Go route(https://go.dev/blog/module-compatibility):
+Instead of fiddling with the old APIs -- whose names felt anachronistic anyway -- we'd define new ones, with better defaults.
+So in July 2018, we looked for better names(https://github.com/python-attrs/attrs/issues/408) and came up with {func}`attr.define`, {func}`attr.field`, and friends.
+Then in January 2019, we started looking for inconvenient defaults(https://github.com/python-attrs/attrs/issues/487) that we now could fix without any repercussions.
+
+These APIs proved to be very popular, so we've finally changed the documentation to them in November of 2021.
+
+All of this took way too long, of course.
+One reason is the COVID-19 pandemic, but also our fear to fumble this historic chance to fix our APIs.
+
+Finally, in December 2021, we've added the *attrs* package namespace.
+
+We hope you like the result:
+
+```
+from attrs import define
+
+@define
+class Point:
+    x: int
+    y: int
+```

_service:tar_scm:attrs-22.2.0.tar.gz/docs/overview.md Added

@@ -0,0 +1,62 @@
+# Overview
+
+In order to fulfill its ambitious goal of bringing back the joy to writing classes, it gives you a class decorator and a way to declaratively define the attributes on that class:
+
+```{include} ../README.md
+:start-after: 'code-begin -->'
+:end-before: '## Project Information'
+```
+
+
+## Philosophy
+
+**It's about regular classes.**
+
+: *attrs* is for creating well-behaved classes with a type, attributes, methods, and everything that comes with a class.
+  It can be used for data-only containers like `namedtuple`s or `types.SimpleNamespace` but they're just a sub-genre of what *attrs* is good for.
+
+
+**The class belongs to the users.**
+
+: You define a class and *attrs* adds static methods to that class based on the attributes you declare.
+  The end.
+  It doesn't add metaclasses.
+  It doesn't add classes you've never heard of to your inheritance tree.
+  An *attrs* class in runtime is indistinguishable from a regular class: because it *is* a regular class with a few boilerplate-y methods attached.
+
+
+**Be light on API impact.**
+
+: As convenient as it seems at first, *attrs* will *not* tack on any methods to your classes except for the {term}`dunder ones <dunder methods>`.
+  Hence all the useful tools(helpers) that come with *attrs* live in functions that operate on top of instances.
+  Since they take an *attrs* instance as their first argument, you can attach them to your classes with one line of code.
+
+
+**Performance matters.**
+
+: *attrs* runtime impact is very close to zero because all the work is done when the class is defined.
+  Once you're instantiating it, *attrs* is out of the picture completely.
+
+
+**No surprises.**
+
+: *attrs* creates classes that arguably work the way a Python beginner would reasonably expect them to work.
+  It doesn't try to guess what you mean because explicit is better than implicit.
+  It doesn't try to be clever because software shouldn't be clever.
+
+Check out {doc}`how-does-it-work` if you'd like to know how it achieves all of the above.
+
+
+## What *attrs* Is Not
+
+*attrs* does *not* invent some kind of magic system that pulls classes out of its hat using meta classes, runtime introspection, and shaky interdependencies.
+
+All *attrs* does is:
+
+1. Take your declaration,
+2. write {term}`dunder methods` based on that information,
+3. and attach them to your class.
+
+It does *nothing* dynamic at runtime, hence zero runtime overhead.
+It's still *your* class.
+Do with it as you please.

_service:tar_scm:attrs-22.2.0.tar.gz/docs/types.md Added

@@ -0,0 +1,106 @@
+# Type Annotations
+
+*attrs* comes with first class support for type annotations for both Python 3.6 ({pep}`526`) and legacy syntax.
+
+However they will forever remain *optional*, therefore the example from the README could also be written as:
+
+```{doctest}
+>>> from attrs import define, field
+
+>>> @define
+... class SomeClass:
+...     a_number = field(default=42)
+...     list_of_numbers = field(factory=list)
+
+>>> sc = SomeClass(1, 1, 2, 3)
+>>> sc
+SomeClass(a_number=1, list_of_numbers=1, 2, 3)
+```
+
+You can choose freely between the approaches, but please remember that if you choose to use type annotations, you **must** annotate **all** attributes!
+
+---
+
+Even when going all-in on type annotations, you will need {func}`attrs.field` for some advanced features though.
+
+One of those features are the decorator-based features like defaults.
+It's important to remember that *attrs* doesn't do any magic behind your back.
+All the decorators are implemented using an object that is returned by the call to {func}`attrs.field`.
+
+Attributes that only carry a class annotation do not have that object so trying to call a method on it will inevitably fail.
+
+---
+
+Please note that types -- regardless how added -- are *only metadata* that can be queried from the class and they aren't used for anything out of the box!
+
+Because Python does not allow references to a class object before the class is defined,
+types may be defined as string literals, so-called *forward references* ({pep}`526`).
+You can enable this automatically for a whole module by using `from __future__ import annotations` ({pep}`563`) as of Python 3.7.
+In this case *attrs* simply puts these string literals into the `type` attributes.
+If you need to resolve these to real types, you can call {func}`attrs.resolve_types` which will update the attribute in place.
+
+In practice though, types show their biggest usefulness in combination with tools like *Mypy*, *pytype*, or *Pyright* 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 write *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
+
+While having a nice syntax for type metadata is great, it's even greater that *Mypy* as of 0.570 ships with a dedicated *attrs* plugin which allows you to statically check your code.
+
+Imagine you add another line that tries to instantiate the defined class using `SomeClass("23")`.
+Mypy will catch that error for you:
+
+```console
+$ mypy t.py
+t.py:12: error: Argument 1 to "SomeClass" has incompatible type "str"; expected "int"
+```
+
+This happens *without* running your code!
+
+And it also works with *both* Python 2-style annotation styles.
+To *Mypy*, this code is equivalent to the one above:
+
+```python
+@attr.s
+class SomeClass:
+    a_number = attr.ib(default=42)  # type: int
+    list_of_numbers = attr.ib(factory=list, type=listint)
+```
+
+
+## Pyright
+
+*attrs* provides support for *Pyright* though the `dataclass_transform` specification.
+This provides static type inference for a subset of *attrs* equivalent to standard-library {mod}`dataclasses`,
+and requires explicit type annotations using the {func}`attrs.define` 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:
+
+```
+@attr.define
+class SomeClass:
+    a_number: int = 42
+    list_of_numbers: listint = attr.field(factory=list)
+```
+
+:::{warning}
+The *Pyright* inferred types are a tiny subset of those supported by *Mypy*, including:
+
+- The generated `__init__` signature only includes the attribute type annotations.
+  It currently does not include attribute `converter` types.
+
+- The `attrs.frozen` decorator is not typed with frozen attributes, which are properly typed via `attrs.define(frozen=True)`.
+
+  A full list(https://github.com/microsoft/pyright/blob/main/specs/dataclass_transforms.md#attrs) of limitations and incompatibilities can be found in *Pyright*'s repository.
+
+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).
+Generally speaking, the decision on improving *attrs* support in *Pyright* is entirely Microsoft's prerogative, though.
+:::
+
+`dataclass_transform`: https://github.com/microsoft/pyright/blob/main/specs/dataclass_transforms.md
+*Mypy*: http://mypy-lang.org
+*Pyright*: https://github.com/microsoft/pyright
+*pytype*: https://google.github.io/pytype/

_service:tar_scm:attrs-22.2.0.tar.gz/docs/why.md Added

@@ -0,0 +1,297 @@
+# Why not…
+
+If you'd like third party's account why *attrs* is great, have a look at Glyph's *The One Python Library Everyone Needs*(https://glyph.twistedmatrix.com/2016/08/attrs.html).
+It predates type annotations and hence Data Classes, but it masterfully illustrates the appeal of class-building packages.
+
+
+## … Data Classes?
+
+{pep}`557` added Data Classes to Python 3.7(https://docs.python.org/3.7/whatsnew/3.7.html#dataclasses) that resemble *attrs* in many ways.
+
+They are the result of the Python community's wish(https://mail.python.org/pipermail/python-ideas/2017-May/045618.html) to have an easier way to write classes in the standard library that doesn't carry the problems of `namedtuple`s.
+To that end, *attrs* and its developers were involved in the PEP process and while we may disagree with some minor decisions that have been made, it's a fine library and if it stops you from abusing `namedtuple`s, they are a huge win.
+
+Nevertheless, there are still reasons to prefer *attrs* over Data Classes.
+Whether they're relevant to *you* depends on your circumstances:
+
+- Data Classes are *intentionally* less powerful than *attrs*.
+  There is a long list of features that were sacrificed for the sake of simplicity and while the most obvious ones are validators, converters, {ref}`equality customization <custom-comparison>`, or {doc}`extensibility <extending>` in general, it permeates throughout all APIs.
+
+  On the other hand, Data Classes currently do not offer any significant feature that *attrs* doesn't already have.
+
+- *attrs* supports all mainstream Python versions including PyPy.
+
+- *attrs* doesn't force type annotations on you if you don't like them.
+
+- But since it **also** supports typing, it's the best way to embrace type hints *gradually*, too.
+
+- While Data Classes are implementing features from *attrs* every now and then, their presence is dependent on the Python version, not the package version.
+  For example, support for `__slots__` has only been added in Python 3.10, but it doesn’t do cell rewriting and therefore doesn’t support bare calls to `super()`.
+  This may or may not be fixed in later Python releases, but handling all these differences is especially painful for PyPI packages that support multiple Python versions.
+  And of course, this includes possible implementation bugs.
+
+- *attrs* can and will move faster.
+  We are not bound to any release schedules and we have a clear deprecation policy.
+
+  One of the reasons(https://peps.python.org/pep-0557/#why-not-just-use-attrs) to not vendor *attrs* in the standard library was to not impede *attrs*'s future development.
+
+One way to think about *attrs* vs Data Classes is that *attrs* is a fully-fledged toolkit to write powerful classes while Data Classes are an easy way to get a class with some attributes.
+Basically what *attrs* was in 2015.
+
+
+## … pydantic?
+
+*pydantic* is first and foremost a *data validation library*.
+As such, it is a capable complement to class building libraries like *attrs* (or Data Classes!) for parsing and validating untrusted data.
+
+However, as convenient as it might be, using it for your business or data layer is problematic in several ways(https://threeofwands.com/why-i-use-attrs-instead-of-pydantic/):
+Is it really necessary to re-validate all your objects while reading them from a trusted database?
+In the parlance of *Form, Command, and Model Validation*(https://verraes.net/2015/02/form-command-model-validation/), *pydantic* is the right tool for *Commands*.
+
+*Separation of concerns*(https://en.wikipedia.org/wiki/Separation_of_concerns) feels tedious at times, but it's one of those things that you get to appreciate once you've shot your own foot often enough.
+
+
+## … namedtuples?
+
+{obj}`collections.namedtuple`s are tuples with names, not classes.^history
+Since writing classes is tiresome in Python, every now and then someone discovers all the typing they could save and gets really excited.
+However, that convenience comes at a price.
+
+The most obvious difference between `namedtuple`s and *attrs*-based classes is that the latter are type-sensitive:
+
+```{doctest}
+>>> import attrs
+>>> C1 = attrs.make_class("C1", "a")
+>>> C2 = attrs.make_class("C2", "a")
+>>> i1 = C1(1)
+>>> i2 = C2(1)
+>>> i1.a == i2.a
+True
+>>> i1 == i2
+False
+```
+
+…while a `namedtuple` is *intentionally* behaving like a tuple(https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences) which means the type of a tuple is *ignored*:
+
+```{doctest}
+>>> from collections import namedtuple
+>>> NT1 = namedtuple("NT1", "a")
+>>> NT2 = namedtuple("NT2", "b")
+>>> t1 = NT1(1)
+>>> t2 = NT2(1)
+>>> t1 == t2 == (1,)
+True
+```
+
+Other often surprising behaviors include:
+
+- Since they are a subclass of tuples, `namedtuple`s have a length and are both iterable and indexable.
+  That's not what you'd expect from a class and is likely to shadow subtle typo bugs.
+
+- Iterability also implies that it's easy to accidentally unpack a `namedtuple` which leads to hard-to-find bugs.^iter
+
+- `namedtuple`s have their methods *on your instances* whether you like it or not.^pollution
+
+- `namedtuple`s are *always* immutable.
+  Not only does that mean that you can't decide for yourself whether your instances should be immutable or not, it also means that if you want to influence your class' initialization (validation? default values?), you have to implement {meth}`__new__() <object.__new__>` which is a particularly hacky and error-prone requirement for a very common problem.^immutable
+
+- To attach methods to a `namedtuple` you have to subclass it.
+  And if you follow the standard library documentation's recommendation of:
+
+  ```
+  class Point(namedtuple('Point', 'x', 'y')):
+      # ...
+  ```
+
+  you end up with a class that has *two* `Point`s in its {attr}`__mro__ <class.__mro__>`: `<class 'point.Point'>, <class 'point.Point'>, <type 'tuple'>, <type 'object'>`.
+
+  That's not only confusing, it also has very practical consequences:
+  for example if you create documentation that includes class hierarchies like **Sphinx*'s autodoc(https://www.sphinx-doc.org/en/stable/usage/extensions/autodoc.html) with `show-inheritance`.
+  Again: common problem, hacky solution with confusing fallout.
+
+All these things make `namedtuple`s a particularly poor choice for public APIs because all your objects are irrevocably tainted.
+With *attrs* your users won't notice a difference because it creates regular, well-behaved classes.
+
+:::{admonition} Summary
+If you want a *tuple with names*, by all means: go for a `namedtuple`.^perf
+But if you want a class with methods, you're doing yourself a disservice by relying on a pile of hacks that requires you to employ even more hacks as your requirements expand.
+
+Other than that, *attrs* also adds nifty features like validators, converters, and (mutable!) default values.
+:::
+
+^history: The word is that `namedtuple`s were added to the Python standard library as a way to make tuples in return values more readable.
+    And indeed that is something you see throughout the standard library.
+
+    Looking at what the makers of `namedtuple`s use it for themselves is a good guideline for deciding on your own use cases.
+
+^pollution: *attrs* only adds a single attribute: `__attrs_attrs__` for introspection.
+    All helpers are functions in the `attr` package.
+    Since they take the instance as first argument, you can easily attach them to your classes under a name of your own choice.
+
+^iter: {func}`attrs.astuple` can be used to get that behavior in *attrs* on *explicit demand*.
+
+^immutable: *attrs* offers *optional* immutability through the `frozen` keyword.
+
+^perf: Although *attrs* would serve you just as well!
+    Since both employ the same method of writing and compiling Python code for you, the performance penalty is negligible at worst and in some cases *attrs* is even faster if you use `slots=True` (which is generally a good idea anyway).
+
+
+## … tuples?
+
+### Readability
+
+What makes more sense while debugging:
+
+```
+Point(x=1, y=2)
+```
+
+or:
+
+```
+(1, 2)
+```
+
+?
+
+Let's add even more ambiguity:
+
+```
+Customer(id=42, reseller=23, first_name="Jane", last_name="John")
+```
+
+or:
+
+```
+(42, 23, "Jane", "John")
+```
+
+?
+
+Why would you want to write `customer2` instead of `customer.first_name`?
+
+Don't get me started when you add nesting.
+If you've never run into mysterious tuples you had no idea what the hell they meant while debugging, you're much smarter than yours truly.
+
+Using proper classes with names and types makes program code much more readable and comprehensible(https://arxiv.org/pdf/1304.5257.pdf).
+Especially when trying to grok a new piece of software or returning to old code after several months.
+
+
+### Extendability
+
+Imagine you have a function that takes or returns a tuple.
+Especially if you use tuple unpacking (eg. `x, y = get_point()`), adding additional data means that you have to change the invocation of that function *everywhere*.
+
+Adding an attribute to a class concerns only those who actually care about that attribute.
+
+
+## … dicts?
+
+Dictionaries are not for fixed fields.
+
+If you have a dict, it maps something to something else.
+You should be able to add and remove values.
+
+*attrs* lets you be specific about those expectations; a dictionary does not.
+It gives you a named entity (the class) in your code, which lets you explain in other places whether you take a parameter of that class or return a value of that class.
+
+In other words: if your dict has a fixed and known set of keys, it is an object, not a hash.
+So if you never iterate over the keys of a dict, you should use a proper class.

_service:tar_scm:attrs-22.1.0.tar.gz/pyproject.toml -> _service:tar_scm:attrs-22.2.0.tar.gz/pyproject.toml Changed

@@ -1,15 +1,24 @@
+# SPDX-License-Identifier: MIT
+
 build-system
 requires = "setuptools>=40.6.0", "wheel"
 build-backend = "setuptools.build_meta"
 
 
+tool.pytest.ini_options
+addopts = "-ra", "--strict-markers", "--strict-config"
+xfail_strict = true
+testpaths = "tests"
+filterwarnings = "once::Warning", "ignore:::pympler.*"
+
+
 tool.coverage.run
 parallel = true
 branch = true
-source = "attr", "attrs"
+source_pkgs = "attr", "attrs"
 
 tool.coverage.paths
-source = "src", ".tox/*/site-packages"
+source = "src", ".tox/py*/**/site-packages"
 
 tool.coverage.report
 show_missing = true
@@ -25,6 +34,10 @@
 line-length = 79
 
 
+tool.isort
+profile = "attrs"
+
+
 tool.interrogate
 verbose = 2
 fail-under = 100
@@ -35,37 +48,33 @@
 toplevel = "attr", "attrs"
 
 
-tool.isort
-profile = "attrs"
-
-
 tool.towncrier
-    package = "attr"
-    package_dir = "src"
-    filename = "CHANGELOG.rst"
-    template = "changelog.d/towncrier_template.rst"
-    issue_format = "`#{issue} <https://github.com/python-attrs/attrs/issues/{issue}>`_"
-    directory = "changelog.d"
-    title_format = "{version} ({project_date})"
-    underlines = "-", "^"
-
-    tool.towncrier.section
-        path = ""
-
-    tool.towncrier.type
-        directory = "breaking"
-        name = "Backwards-incompatible Changes"
-        showcontent = true
-
-    tool.towncrier.type
-        directory = "deprecation"
-        name = "Deprecations"
-        showcontent = true
-
-    tool.towncrier.type
-        directory = "change"
-        name = "Changes"
-        showcontent = true
+name = "attrs"
+directory = "changelog.d"
+filename = "CHANGELOG.md"
+start_string = "\n"
+template = "changelog.d/towncrier_template.md.jinja"
+title_format = ""
+issue_format = "#{issue}(https://github.com/python-attrs/attrs/issues/{issue})"
+underlines = "", "", ""
+
+tool.towncrier.section
+path = ""
+
+tool.towncrier.type
+directory = "breaking"
+name = "Backwards-incompatible Changes"
+showcontent = true
+
+tool.towncrier.type
+directory = "deprecation"
+name = "Deprecations"
+showcontent = true
+
+tool.towncrier.type
+directory = "change"
+name = "Changes"
+showcontent = true
 
 
 tool.mypy

_service:tar_scm:attrs-22.2.0.tar.gz/readthedocs.yml Added

_service:tar_scm:attrs-22.1.0.tar.gz/setup.py -> _service:tar_scm:attrs-22.2.0.tar.gz/setup.py Changed

@@ -2,9 +2,7 @@
 
 import codecs
 import os
-import platform
 import re
-import sys
 
 from setuptools import find_packages, setup
 
@@ -14,7 +12,7 @@
 NAME = "attrs"
 PACKAGES = find_packages(where="src")
 META_PATH = os.path.join("src", "attr", "__init__.py")
-KEYWORDS = "class", "attribute", "boilerplate"
+KEYWORDS = "class", "attribute", "boilerplate", "dataclass"
 PROJECT_URLS = {
     "Documentation": "https://www.attrs.org/",
     "Changelog": "https://www.attrs.org/en/stable/changelog.html",
@@ -33,7 +31,6 @@
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.5",
     "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
@@ -46,29 +43,45 @@
 
 INSTALL_REQUIRES = 
 EXTRAS_REQUIRE = {
-    "docs": "furo", "sphinx", "zope.interface", "sphinx-notfound-page",
-    "tests_no_zope": 
+    "docs": 
+        "furo",
+        "sphinx",
+        "myst-parser",
+        "zope.interface",
+        "sphinx-notfound-page",
+        "sphinxcontrib-towncrier",
+        "towncrier",
+    ,
+    "tests-no-zope": 
         # For regression test to ensure cloudpickle compat doesn't break.
         'cloudpickle; python_implementation == "CPython"',
-        # 5.0 introduced toml; parallel was broken until 5.0.2
-        "coveragetoml>=5.0.2",
         "hypothesis",
         "pympler",
-        "pytest>=4.3.0",  # 4.3.0 dropped last use of `convert`
+        # 4.3.0 dropped last use of `convert`
+        "pytest>=4.3.0",
+        # psutil extra is needed for correct core count detection.
+        "pytest-xdistpsutil",
+        # Since the mypy error messages keep changing, we have to keep updating
+        # this pin.
+        "mypy>=0.971,<0.990; python_implementation == 'CPython'",
+        "pytest-mypy-plugins; python_implementation == 'CPython' and "
+        "python_version<'3.11'",
+    ,
+    "tests": 
+        "attrstests-no-zope",
+        "zope.interface",
+    ,
+    "cov": 
+        "attrstests",
+        "coverage-enable-subprocess",
+        # Ensure coverage is new enough for `source_pkgs`.
+        "coveragetoml>=5.3",
     ,
+    "dev": "attrstests,docs",
 }
-if (
-    sys.version_info:2 >= (3, 6)
-    and platform.python_implementation() != "PyPy"
-):
-    EXTRAS_REQUIRE"tests_no_zope".extend(
-        "mypy>=0.900,!=0.940", "pytest-mypy-plugins"
-    )
+# Don't break Paul unnecessarily just yet. C.f. #685
+EXTRAS_REQUIRE"tests_no_zope" = EXTRAS_REQUIRE"tests-no-zope"
 
-EXTRAS_REQUIRE"tests" = EXTRAS_REQUIRE"tests_no_zope" + "zope.interface"
-EXTRAS_REQUIRE"dev" = (
-    EXTRAS_REQUIRE"tests" + EXTRAS_REQUIRE"docs" + "pre-commit"
-)
 
 ###############################################################################
 
@@ -92,38 +105,38 @@
     Extract __*meta*__ from META_FILE.
     """
     meta_match = re.search(
-        r"^__{meta}__ = '\"(^'\"*)'\"".format(meta=meta), META_FILE, re.M
+        rf"^__{meta}__ = '\"(^'\"*)'\"", META_FILE, re.M
     )
     if meta_match:
         return meta_match.group(1)
-    raise RuntimeError("Unable to find __{meta}__ string.".format(meta=meta))
+    raise RuntimeError(f"Unable to find __{meta}__ string.")
 
 
-LOGO = """
-.. image:: https://www.attrs.org/en/stable/_static/attrs_logo.png
-   :alt: attrs logo
-   :align: center
-"""  # noqa
-
 VERSION = find_meta("version")
 URL = find_meta("url")
+
+# PyPI doesn't support the <picture> tag.
+LOGO = """<p align="center">
+  <a href="https://www.attrs.org/">
+    <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/docs/_static/attrs_logo.svg" width="35%" alt="attrs" />
+  </a>
+</p>
+"""  # noqa
+
 LONG = (
     LOGO
-    + read("README.rst").split(".. teaser-begin")1
-    + "\n\n"
-    + "Release Information\n"
-    + "===================\n\n"
-    + re.search(
-        r"(\d+.\d.\d $.*?$\r?\n.*?)\r?\n\r?\n\r?\n----\r?\n\r?\n\r?\n",
-        read("CHANGELOG.rst"),
-        re.S,
-    ).group(1)
-    + "\n\n`Full changelog "
-    + "<{url}en/stable/changelog.html>`_.\n\n".format(url=URL)
-    + read("AUTHORS.rst")
+    + read("README.md").split("", 1)1
+    + "\n\n## Changes in This Release\n"
+    + read("CHANGELOG.md")
+    .split("towncrier release notes start -->", 1)1
+    .strip()
+    .split("\n## ", 1)0
+    .strip()
+    .split("\n", 1)1
+    + "\n\n---\n\nFull changelog"
+    "(https://www.attrs.org/en/stable/changelog.html)\n"
 )
 
-
 if __name__ == "__main__":
     setup(
         name=NAME,
@@ -138,14 +151,13 @@
         maintainer_email=find_meta("email"),
         keywords=KEYWORDS,
         long_description=LONG,
-        long_description_content_type="text/x-rst",
+        long_description_content_type="text/markdown",
         packages=PACKAGES,
         package_dir={"": "src"},
-        python_requires=">=3.5",
+        python_requires=">=3.6",
         zip_safe=False,
         classifiers=CLASSIFIERS,
         install_requires=INSTALL_REQUIRES,
         extras_require=EXTRAS_REQUIRE,
         include_package_data=True,
-        options={"bdist_wheel": {"universal": "1"}},
     )

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/__init__.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/__init__.py Changed

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 
-
 import sys
+import warnings
 
 from functools import partial
 
@@ -20,10 +20,19 @@
     make_class,
     validate,
 )
+from ._next_gen import define, field, frozen, mutable
 from ._version_info import VersionInfo
 
 
-__version__ = "22.1.0"
+if sys.version_info < (3, 7):  # pragma: no cover
+    warnings.warn(
+        "Running attrs on Python 3.6 is deprecated & we intend to drop "
+        "support soon. If that's a problem for you, please let us know why & "
+        "we MAY re-evaluate: <https://github.com/python-attrs/attrs/pull/993>",
+        DeprecationWarning,
+    )
+
+__version__ = "22.2.0"
 __version_info__ = VersionInfo._from_version_string(__version__)
 
 __title__ = "attrs"
@@ -43,8 +52,14 @@
 ib = attr = attrib
 dataclass = partial(attrs, auto_attribs=True)  # happy Easter ;)
 
+
+class AttrsInstance:
+    pass
+
+
 __all__ = 
     "Attribute",
+    "AttrsInstance",
     "Factory",
     "NOTHING",
     "asdict",
@@ -56,15 +71,19 @@
     "attrs",
     "cmp_using",
     "converters",
+    "define",
     "evolve",
     "exceptions",
+    "field",
     "fields",
     "fields_dict",
     "filters",
+    "frozen",
     "get_run_validators",
     "has",
     "ib",
     "make_class",
+    "mutable",
     "resolve_types",
     "s",
     "set_run_validators",
@@ -72,8 +91,3 @@
     "validate",
     "validators",
 
-
-if sys.version_info:2 >= (3, 6):
-    from ._next_gen import define, field, frozen, mutable  # noqa: F401
-
-    __all__.extend(("define", "field", "frozen", "mutable"))

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/__init__.pyi -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/__init__.pyi Changed

@@ -1,9 +1,9 @@
+import enum
 import sys
 
 from typing import (
     Any,
     Callable,
-    ClassVar,
     Dict,
     Generic,
     List,
@@ -25,8 +25,14 @@
 from . import setters as setters
 from . import validators as validators
 from ._cmp import cmp_using as cmp_using
+from ._typing_compat import AttrsInstance_
 from ._version_info import VersionInfo
 
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
 __version__: str
 __version_info__: VersionInfo
 __title__: str
@@ -42,30 +48,33 @@
 _C = TypeVar("_C", bound=type)
 
 _EqOrderType = Unionbool, CallableAny, Any
-_ValidatorType = CallableAny, Attribute_T, _T, Any
+_ValidatorType = CallableAny, "Attribute_T", _T, Any
 _ConverterType = CallableAny, Any
-_FilterType = CallableAttribute_T, _T, bool
+_FilterType = Callable"Attribute_T", _T, bool
 _ReprType = CallableAny, str
 _ReprArgType = Unionbool, _ReprType
-_OnSetAttrType = CallableAny, AttributeAny, Any, Any
+_OnSetAttrType = CallableAny, "AttributeAny", Any, Any
 _OnSetAttrArgType = Union
     _OnSetAttrType, List_OnSetAttrType, setters._NoOpType
 
 _FieldTransformer = Callable
-    type, ListAttributeAny, ListAttributeAny
+    type, List"AttributeAny", List"AttributeAny"
 
 # FIXME: in reality, if multiple validators are passed they must be in a list
 # or tuple, but those are invariant and so would prevent subtypes of
 # _ValidatorType from working when passed in a list or tuple.
 _ValidatorArgType = Union_ValidatorType_T, Sequence_ValidatorType_T
 
-# A protocol to be able to statically accept an attrs class.
-class AttrsInstance(Protocol):
-    __attrs_attrs__: ClassVarAny
+# We subclass this here to keep the protocol's qualified name clean.
+class AttrsInstance(AttrsInstance_, Protocol):
+    pass
 
 # _make --
 
-NOTHING: object
+class _Nothing(enum.Enum):
+    NOTHING = enum.auto()
+
+NOTHING = _Nothing.NOTHING
 
 # NOTE: Factory lies about its return type to make this possible:
 # `x: Listint # = Factory(list)`
@@ -125,6 +134,8 @@
     type: OptionalType_T
     kw_only: bool
     on_setattr: _OnSetAttrType
+    alias: Optionalstr
+
     def evolve(self, **changes: Any) -> "AttributeAny": ...
 
 # NOTE: We had several choices for the annotation to use for type arg:
@@ -167,6 +178,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> Any: ...
 
 # This form catches an explicit None or no default and infers the type from the
@@ -187,6 +199,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> _T: ...
 
 # This form catches an explicit default argument.
@@ -206,6 +219,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> _T: ...
 
 # This form covers type=non-Type: e.g. forward references (str), Any
@@ -225,6 +239,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> Any: ...
 @overload
 def field(
@@ -241,6 +256,7 @@
     eq: Optionalbool = ...,
     order: Optionalbool = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> Any: ...
 
 # This form catches an explicit None or no default and infers the type from the
@@ -260,6 +276,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> _T: ...
 
 # This form catches an explicit default argument.
@@ -278,6 +295,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> _T: ...
 
 # This form covers type=non-Type: e.g. forward references (str), Any
@@ -296,6 +314,7 @@
     eq: Optional_EqOrderType = ...,
     order: Optional_EqOrderType = ...,
     on_setattr: Optional_OnSetAttrArgType = ...,
+    alias: Optionalstr = ...,
 ) -> Any: ...
 @overload
 @__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
@@ -323,6 +342,7 @@
     on_setattr: Optional_OnSetAttrArgType = ...,
     field_transformer: Optional_FieldTransformer = ...,
     match_args: bool = ...,
+    unsafe_hash: Optionalbool = ...,
 ) -> _C: ...
 @overload
 @__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
@@ -350,6 +370,7 @@
     on_setattr: Optional_OnSetAttrArgType = ...,
     field_transformer: Optional_FieldTransformer = ...,
     match_args: bool = ...,
+    unsafe_hash: Optionalbool = ...,
 ) -> Callable_C, _C: ...
 @overload
 @__dataclass_transform__(field_descriptors=(attrib, field))
@@ -358,6 +379,7 @@
     *,
     these: OptionalDictstr, Any = ...,
     repr: bool = ...,
+    unsafe_hash: Optionalbool = ...,
     hash: Optionalbool = ...,
     init: bool = ...,
     slots: bool = ...,
@@ -383,6 +405,7 @@
     *,
     these: OptionalDictstr, Any = ...,
     repr: bool = ...,
+    unsafe_hash: Optionalbool = ...,
     hash: Optionalbool = ...,
     init: bool = ...,
     slots: bool = ...,
@@ -470,7 +493,7 @@
     tuple_factory: TypeSequenceAny = ...,
     retain_collection_types: bool = ...,
 ) -> TupleAny, ...: ...
-def has(cls: type) -> bool: ...
+def has(cls: type) -> TypeGuardTypeAttrsInstance: ...
 def assoc(inst: _T, **changes: Any) -> _T: ...
 def evolve(inst: _T, **changes: Any) -> _T: ...

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/_cmp.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_cmp.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/_cmp.pyi -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_cmp.pyi Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/_compat.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_compat.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/_funcs.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_funcs.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/_make.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_make.py Changed

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 
 import copy
+import enum
 import linecache
 import sys
 import types
@@ -11,14 +12,7 @@
 # We need to import _compat itself in addition to the _compat members to avoid
 # having the thread-local in the globals here.
 from . import _compat, _config, setters
-from ._compat import (
-    HAS_F_STRINGS,
-    PY310,
-    PYPY,
-    _AnnotationExtractor,
-    ordered_dict,
-    set_closure_cell,
-)
+from ._compat import PY310, PYPY, _AnnotationExtractor, set_closure_cell
 from .exceptions import (
     DefaultAlreadySetError,
     FrozenInstanceError,
@@ -30,10 +24,7 @@
 # This is used at least twice, so cache it here.
 _obj_setattr = object.__setattr__
 _init_converter_pat = "__attr_converter_%s"
-_init_factory_pat = "__attr_factory_{}"
-_tuple_property_pat = (
-    "    {attr_name} = _attrs_property(_attrs_itemgetter({index}))"
-)
+_init_factory_pat = "__attr_factory_%s"
 _classvar_prefixes = (
     "typing.ClassVar",
     "t.ClassVar",
@@ -53,21 +44,18 @@
 _ng_default_on_setattr = setters.pipe(setters.convert, setters.validate)
 
 
-class _Nothing:
+class _Nothing(enum.Enum):
     """
-    Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
+    Sentinel to indicate the lack of a value when ``None`` is ambiguous.
 
-    ``_Nothing`` is a singleton. There is only ever one of it.
+    If extending attrs, you can use ``typing.LiteralNOTHING`` to show
+    that a value may be ``NOTHING``.
 
     .. versionchanged:: 21.1.0 ``bool(NOTHING)`` is now False.
+    .. versionchanged:: 22.2.0 ``NOTHING`` is now an ``enum.Enum`` variant.
     """
 
-    _singleton = None
-
-    def __new__(cls):
-        if _Nothing._singleton is None:
-            _Nothing._singleton = super().__new__(cls)
-        return _Nothing._singleton
+    NOTHING = enum.auto()
 
     def __repr__(self):
         return "NOTHING"
@@ -76,7 +64,7 @@
         return False
 
 
-NOTHING = _Nothing()
+NOTHING = _Nothing.NOTHING
 """
 Sentinel to indicate the lack of a value when ``None`` is ambiguous.
 """
@@ -113,6 +101,7 @@
     eq=None,
     order=None,
     on_setattr=None,
+    alias=None,
 ):
     """
     Create a new attribute on a class.
@@ -200,10 +189,10 @@
         returned value will be used as the new value of the attribute.  The
         value is converted before being passed to the validator, if any.
     :param metadata: An arbitrary mapping, to be used by third-party
-        components.  See `extending_metadata`.
-    :param type: The type of the attribute.  In Python 3.6 or greater, the
-        preferred method to specify the type is using a variable annotation
-        (see :pep:`526`).
+        components.  See `extending-metadata`.
+
+    :param type: The type of the attribute. Nowadays, the preferred method to
+        specify the type is using a variable annotation (see :pep:`526`).
         This argument is provided for backward compatibility.
         Regardless of the approach used, the type will be stored on
         ``Attribute.type``.
@@ -211,15 +200,17 @@
         Please note that ``attrs`` doesn't do anything with this metadata by
         itself. You can use it as part of your own code or for
         `static type checking <types>`.
-    :param kw_only: Make this attribute keyword-only (Python 3+)
-        in the generated ``__init__`` (if ``init`` is ``False``, this
-        parameter is ignored).
+    :param kw_only: Make this attribute keyword-only in the generated
+        ``__init__`` (if ``init`` is ``False``, this parameter is ignored).
     :param on_setattr: Allows to overwrite the *on_setattr* setting from
         `attr.s`. If left `None`, the *on_setattr* value from `attr.s` is used.
         Set to `attrs.setters.NO_OP` to run **no** `setattr` hooks for this
         attribute -- regardless of the setting in `attr.s`.
     :type on_setattr: `callable`, or a list of callables, or `None`, or
         `attrs.setters.NO_OP`
+    :param Optionalstr alias: Override this attribute's parameter name in the
+        generated ``__init__`` method. If left `None`, default to ``name``
+        stripped of leading underscores. See `private-attributes`.
 
     .. versionadded:: 15.2.0 *convert*
     .. versionadded:: 16.3.0 *metadata*
@@ -242,6 +233,7 @@
     .. versionchanged:: 21.1.0
        *eq*, *order*, and *cmp* also accept a custom callable
     .. versionchanged:: 21.1.0 *cmp* undeprecated
+    .. versionadded:: 22.2.0 *alias*
     """
     eq, eq_key, order, order_key = _determine_attrib_eq_order(
         cmp, eq, order, True
@@ -291,6 +283,7 @@
         order=order,
         order_key=order_key,
         on_setattr=on_setattr,
+        alias=alias,
     )
 
 
@@ -323,7 +316,7 @@
         if old_val == linecache_tuple:
             break
         else:
-            filename = "{}-{}>".format(base_filename:-1, count)
+            filename = f"{base_filename:-1}-{count}>"
             count += 1
 
     _compile_and_eval(script, globs, locs, filename)
@@ -341,15 +334,15 @@
         __slots__ = ()
         x = property(itemgetter(0))
     """
-    attr_class_name = "{}Attributes".format(cls_name)
+    attr_class_name = f"{cls_name}Attributes"
     attr_class_template = 
-        "class {}(tuple):".format(attr_class_name),
+        f"class {attr_class_name}(tuple):",
         "    __slots__ = ()",
     
     if attr_names:
         for i, attr_name in enumerate(attr_names):
             attr_class_template.append(
-                _tuple_property_pat.format(index=i, attr_name=attr_name)
+                f"    {attr_name} = _attrs_property(_attrs_itemgetter({i}))"
             )
     else:
         attr_class_template.append("    pass")
@@ -393,8 +386,6 @@
 def _has_own_attribute(cls, attrib_name):
     """
     Check whether *cls* defines *attrib_name* (and doesn't just inherit it).
-
-    Requires Python 3.
     """
     attr = getattr(cls, attrib_name, _sentinel)
     if attr is _sentinel:
@@ -418,13 +409,6 @@
     return {}
 
 
-def _counter_getter(e):
-    """
-    Key function for sorting to avoid re-creating a lambda for every class.
-    """
-    return e1.counter
-
-
 def _collect_base_attrs(cls, taken_attr_names):
     """
     Collect attr.ibs from base classes of *cls*, except *taken_attr_names*.
@@ -502,9 +486,6 @@
 
     if these is not None:
         ca_list = (name, ca) for name, ca in these.items()
-
-        if not isinstance(these, ordered_dict):
-            ca_list.sort(key=_counter_getter)
     elif auto_attribs is True:
         ca_names = {
             name
@@ -576,7 +557,7 @@
         if had_default is True and a.default is NOTHING:
             raise ValueError(
                 "No mandatory attributes allowed after an attribute with a "
-                "default value or factory.  Attribute in question: %r" % (a,)
+                f"default value or factory.  Attribute in question: {a!r}"

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/_next_gen.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_next_gen.py Changed

@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MIT
 
 """
-These are Python 3.6+-only and keyword-only APIs that call `attr.s` and
-`attr.ib` with different default values.
+These are keyword-only APIs that call `attr.s` and `attr.ib` with different
+default values.
 """
 
 
@@ -26,6 +26,7 @@
     *,
     these=None,
     repr=None,
+    unsafe_hash=None,
     hash=None,
     init=None,
     slots=True,
@@ -81,6 +82,8 @@
 
     .. versionadded:: 20.1.0
     .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``.
+    .. versionadded:: 22.2.0
+       *unsafe_hash* as an alias for *hash* (for :pep:`681` compliance).
     """
 
     def do_it(cls, auto_attribs):
@@ -89,6 +92,7 @@
             these=these,
             repr=repr,
             hash=hash,
+            unsafe_hash=unsafe_hash,
             init=init,
             slots=slots,
             frozen=frozen,
@@ -169,6 +173,7 @@
     eq=None,
     order=None,
     on_setattr=None,
+    alias=None,
 ):
     """
     Identical to `attr.ib`, except keyword-only and with some arguments
@@ -189,6 +194,7 @@
         eq=eq,
         order=order,
         on_setattr=on_setattr,
+        alias=alias,
     )

_service:tar_scm:attrs-22.2.0.tar.gz/src/attr/_typing_compat.pyi Added

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/converters.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/converters.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/converters.pyi -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/converters.pyi Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/setters.pyi -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/setters.pyi Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/validators.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/validators.py Changed

@@ -12,6 +12,7 @@
 
 from ._config import get_run_validators, set_run_validators
 from ._make import _AndValidator, and_, attrib, attrs
+from .converters import default_if_none
 from .exceptions import NotCallableError
 
 
@@ -37,6 +38,7 @@
     "matches_re",
     "max_len",
     "min_len",
+    "not_",
     "optional",
     "provides",
     "set_disabled",
@@ -126,7 +128,7 @@
     `isinstance` therefore it's also valid to pass a tuple of types).
 
     :param type: The type to check for.
-    :type type: type or tuple of types
+    :type type: type or tuple of type
 
     :raises TypeError: With a human readable error message, the attribute
         (of type `attrs.Attribute`), the expected type, and the value it
@@ -391,7 +393,7 @@
         iterable_identifier = (
             ""
             if self.iterable_validator is None
-            else " {iterable!r}".format(iterable=self.iterable_validator)
+            else f" {self.iterable_validator!r}"
         )
         return (
             "<deep_iterable validator for{iterable_identifier}"
@@ -548,7 +550,7 @@
             )
 
     def __repr__(self):
-        return "<max_len validator for {max}>".format(max=self.max_length)
+        return f"<max_len validator for {self.max_length}>"
 
 
 def max_len(length):
@@ -579,7 +581,7 @@
             )
 
     def __repr__(self):
-        return "<min_len validator for {min}>".format(min=self.min_length)
+        return f"<min_len validator for {self.min_length}>"
 
 
 def min_len(length):
@@ -592,3 +594,121 @@
     .. versionadded:: 22.1.0
     """
     return _MinLengthValidator(length)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _SubclassOfValidator:
+    type = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not issubclass(value, self.type):
+            raise TypeError(
+                "'{name}' must be a subclass of {type!r} "
+                "(got {value!r}).".format(
+                    name=attr.name,
+                    type=self.type,
+                    value=value,
+                ),
+                attr,
+                self.type,
+                value,
+            )
+
+    def __repr__(self):
+        return "<subclass_of validator for type {type!r}>".format(
+            type=self.type
+        )
+
+
+def _subclass_of(type):
+    """
+    A validator that raises a `TypeError` if the initializer is called
+    with a wrong type for this particular attribute (checks are performed using
+    `issubclass` therefore it's also valid to pass a tuple of types).
+
+    :param type: The type to check for.
+    :type type: type or tuple of types
+
+    :raises TypeError: With a human readable error message, the attribute
+        (of type `attrs.Attribute`), the expected type, and the value it
+        got.
+    """
+    return _SubclassOfValidator(type)
+
+
+@attrs(repr=False, slots=True, hash=True)
+class _NotValidator:
+    validator = attrib()
+    msg = attrib(
+        converter=default_if_none(
+            "not_ validator child '{validator!r}' "
+            "did not raise a captured error"
+        )
+    )
+    exc_types = attrib(
+        validator=deep_iterable(
+            member_validator=_subclass_of(Exception),
+            iterable_validator=instance_of(tuple),
+        ),
+    )
+
+    def __call__(self, inst, attr, value):
+        try:
+            self.validator(inst, attr, value)
+        except self.exc_types:
+            pass  # suppress error to invert validity
+        else:
+            raise ValueError(
+                self.msg.format(
+                    validator=self.validator,
+                    exc_types=self.exc_types,
+                ),
+                attr,
+                self.validator,
+                value,
+                self.exc_types,
+            )
+
+    def __repr__(self):
+        return (
+            "<not_ validator wrapping {what!r}, " "capturing {exc_types!r}>"
+        ).format(
+            what=self.validator,
+            exc_types=self.exc_types,
+        )
+
+
+def not_(validator, *, msg=None, exc_types=(ValueError, TypeError)):
+    """
+    A validator that wraps and logically 'inverts' the validator passed to it.
+    It will raise a `ValueError` if the provided validator *doesn't* raise a
+    `ValueError` or `TypeError` (by default), and will suppress the exception
+    if the provided validator *does*.
+
+    Intended to be used with existing validators to compose logic without
+    needing to create inverted variants, for example, ``not_(in_(...))``.
+
+    :param validator: A validator to be logically inverted.
+    :param msg: Message to raise if validator fails.
+        Formatted with keys ``exc_types`` and ``validator``.
+    :type msg: str
+    :param exc_types: Exception type(s) to capture.
+        Other types raised by child validators will not be intercepted and
+        pass through.
+
+    :raises ValueError: With a human readable error message,
+        the attribute (of type `attrs.Attribute`),
+        the validator that failed to raise an exception,
+        the value it got,
+        and the expected exception types.
+
+    .. versionadded:: 22.2.0
+    """
+    try:
+        exc_types = tuple(exc_types)
+    except TypeError:
+        exc_types = (exc_types,)
+    return _NotValidator(validator, msg, exc_types)

_service:tar_scm:attrs-22.1.0.tar.gz/src/attr/validators.pyi -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attr/validators.pyi Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attrs/__init__.py -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attrs/__init__.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/src/attrs/__init__.pyi -> _service:tar_scm:attrs-22.2.0.tar.gz/src/attrs/__init__.pyi Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/attr_import_star.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/attr_import_star.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/dataclass_transform_example.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/dataclass_transform_example.py Changed

_service:tar_scm:attrs-22.2.0.tar.gz/tests/test_abc.py Added

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+
+import abc
+import inspect
+
+import pytest
+
+import attrs
+
+from attr._compat import PY310, PY_3_12_PLUS
+
+
+@pytest.mark.skipif(not PY310, reason="abc.update_abstractmethods is 3.10+")
+class TestUpdateAbstractMethods:
+    def test_abc_implementation(self, slots):
+        """
+        If an attrs class implements an abstract method, it stops being
+        abstract.
+        """
+
+        class Ordered(abc.ABC):
+            @abc.abstractmethod
+            def __lt__(self, other):
+                pass
+
+            @abc.abstractmethod
+            def __le__(self, other):
+                pass
+
+        @attrs.define(order=True, slots=slots)
+        class Concrete(Ordered):
+            x: int
+
+        assert not inspect.isabstract(Concrete)
+        assert Concrete(2) > Concrete(1)
+
+    def test_remain_abstract(self, slots):
+        """
+        If an attrs class inherits from an abstract class but doesn't implement
+        abstract methods, it remains abstract.
+        """
+
+        class A(abc.ABC):
+            @abc.abstractmethod
+            def foo(self):
+                pass
+
+        @attrs.define(slots=slots)
+        class StillAbstract(A):
+            pass
+
+        assert inspect.isabstract(StillAbstract)
+        expected_exception_message = (
+            "^Can't instantiate abstract class StillAbstract without an "
+            "implementation for abstract method 'foo'$"
+            if PY_3_12_PLUS
+            else "class StillAbstract with abstract method foo"
+        )
+        with pytest.raises(TypeError, match=expected_exception_message):
+            StillAbstract()

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_annotations.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_annotations.py Changed

@@ -2,8 +2,6 @@
 
 """
 Tests for PEP-526 type annotations.
-
-Python 3.6+ only.
 """
 
 import sys
@@ -98,7 +96,6 @@
         sys.version_info:2 < (3, 11),
         reason="Incompatible behavior on older Pythons",
     )
-    @pytest.mark.parametrize("slots", True, False)
     def test_auto_attribs(self, slots):
         """
         If *auto_attribs* is True, bare annotations are collected too.
@@ -156,7 +153,6 @@
             foo=typing.Any,
         )
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_auto_attribs_unannotated(self, slots):
         """
         Unannotated `attr.ib`s raise an error.
@@ -174,7 +170,6 @@
             "The following `attr.ib`s lack a type annotation: v, y.",
         ) == e.value.args
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_auto_attribs_subclassing(self, slots):
         """
         Attributes from base classes are inherited, it doesn't matter if the
@@ -392,12 +387,11 @@
         sys.version_info:2 < (3, 11),
         reason="Incompatible behavior on older Pythons",
     )
-    @pytest.mark.parametrize("slots", True, False)
     def test_annotations_strings(self, slots):
         """
         String annotations are passed into __init__ as is.
 
-        It fails on 3.6 due to a bug in Python.
+        The strings keep changing between releases.
         """
         import typing as t
 
@@ -425,7 +419,6 @@
             foo=typing.Any,
         )
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_typing_extensions_classvar(self, slots):
         """
         If ClassVar is coming from typing_extensions, it is recognized too.
@@ -523,7 +516,6 @@
         assert str is attr.fields(C).y.type
         assert None is attr.fields(C).z.type
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_resolve_types_auto_attrib(self, slots):
         """
         Types can be resolved even when strings are involved.
@@ -543,7 +535,6 @@
         assert typing.Listint == attr.fields(A).b.type
         assert typing.Listint == attr.fields(A).c.type
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_resolve_types_decorator(self, slots):
         """
         Types can be resolved using it as a decorator.
@@ -560,7 +551,6 @@
         assert typing.Listint == attr.fields(A).b.type
         assert typing.Listint == attr.fields(A).c.type
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_self_reference(self, slots):
         """
         References to self class using quotes can be resolved.
@@ -576,7 +566,6 @@
         assert A == attr.fields(A).a.type
         assert typing.OptionalA == attr.fields(A).b.type
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_forward_reference(self, slots):
         """
         Forward references can be resolved.

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_dunders.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_dunders.py Changed

@@ -21,7 +21,6 @@
     _add_repr,
     _is_slot_cls,
     _make_init,
-    _Nothing,
     fields,
     make_class,
 )
@@ -320,7 +319,6 @@
     Tests for `_add_repr`.
     """
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_repr(self, slots):
         """
         If `repr` is False, ignore that attribute.
@@ -646,8 +644,6 @@
         assert 1 == cached_instance.hash_counter.times_hash_called
 
     @pytest.mark.parametrize("cache_hash", True, False)
-    @pytest.mark.parametrize("frozen", True, False)
-    @pytest.mark.parametrize("slots", True, False)
     def test_copy_hash_cleared(self, cache_hash, frozen, slots):
         """
         Test that the default hash is recalculated after a copy operation.
@@ -701,7 +697,6 @@
 
         assert original_hash != hash(obj_rt)
 
-    @pytest.mark.parametrize("frozen", True, False)
     def test_copy_two_arg_reduce(self, frozen):
         """
         If __getstate__ returns None, the tuple returned by object.__reduce__
@@ -907,30 +902,30 @@
 
 class TestNothing:
     """
-    Tests for `_Nothing`.
+    Tests for `NOTHING`.
     """
 
     def test_copy(self):
         """
         __copy__ returns the same object.
         """
-        n = _Nothing()
+        n = NOTHING
         assert n is copy.copy(n)
 
     def test_deepcopy(self):
         """
         __deepcopy__ returns the same object.
         """
-        n = _Nothing()
+        n = NOTHING
         assert n is copy.deepcopy(n)
 
     def test_eq(self):
         """
         All instances are equal.
         """
-        assert _Nothing() == _Nothing() == NOTHING
-        assert not (_Nothing() != _Nothing())
-        assert 1 != _Nothing()
+        assert NOTHING == NOTHING == NOTHING
+        assert not (NOTHING != NOTHING)
+        assert 1 != NOTHING
 
     def test_false(self):
         """

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_funcs.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_funcs.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_functional.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_functional.py Changed

@@ -17,7 +17,6 @@
 
 import attr
 
-from attr._compat import PY36
 from attr._make import NOTHING, Attribute
 from attr.exceptions import FrozenInstanceError
 
@@ -120,6 +119,7 @@
         assert (
             Attribute(
                 name="x",
+                alias="x",
                 default=foo,
                 validator=None,
                 repr=True,
@@ -132,6 +132,7 @@
             ),
             Attribute(
                 name="y",
+                alias="y",
                 default=attr.Factory(list),
                 validator=None,
                 repr=True,
@@ -189,6 +190,7 @@
         assert (
             Attribute(
                 name="a",
+                alias="a",
                 default=NOTHING,
                 validator=None,
                 repr=True,
@@ -201,6 +203,7 @@
             ),
             Attribute(
                 name="b",
+                alias="b",
                 default=NOTHING,
                 validator=None,
                 repr=True,
@@ -224,9 +227,9 @@
         assert i.x is i.meth() is obj
         assert i.y == 2
         if cls is Sub:
-            assert "Sub(x={obj}, y=2)".format(obj=obj) == repr(i)
+            assert f"Sub(x={obj}, y=2)" == repr(i)
         else:
-            assert "SubSlots(x={obj}, y=2)".format(obj=obj) == repr(i)
+            assert f"SubSlots(x={obj}, y=2)" == repr(i)
 
     @pytest.mark.parametrize("base", Base, BaseSlots)
     def test_subclass_without_extra_attrs(self, base):
@@ -241,7 +244,7 @@
         obj = object()
         i = Sub2(x=obj)
         assert i.x is i.meth() is obj
-        assert "Sub2(x={obj})".format(obj=obj) == repr(i)
+        assert f"Sub2(x={obj})" == repr(i)
 
     @pytest.mark.parametrize(
         "frozen_class",
@@ -354,8 +357,6 @@
 
         assert C(1, 2) == C()
 
-    @pytest.mark.parametrize("slots", True, False)
-    @pytest.mark.parametrize("frozen", True, False)
     @pytest.mark.parametrize("weakref_slot", True, False)
     def test_attrib_overwrite(self, slots, frozen, weakref_slot):
         """
@@ -424,7 +425,6 @@
         class D(C):
             pass
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_hash_false_eq_false(self, slots):
         """
         hash=False and eq=False make a class hashable by ID.
@@ -436,7 +436,6 @@
 
         assert hash(C()) != hash(C())
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_eq_false(self, slots):
         """
         eq=False makes a class hashable by ID.
@@ -544,8 +543,6 @@
         assert "itemgetter" == attr.fields(C).itemgetter.name
         assert "x" == attr.fields(C).x.name
 
-    @pytest.mark.parametrize("slots", True, False)
-    @pytest.mark.parametrize("frozen", True, False)
     def test_auto_exc(self, slots, frozen):
         """
         Classes with auto_exc=True have a Exception-style __str__, compare and
@@ -600,8 +597,6 @@
                 deepcopy(e1)
                 deepcopy(e2)
 
-    @pytest.mark.parametrize("slots", True, False)
-    @pytest.mark.parametrize("frozen", True, False)
     def test_auto_exc_one_attrib(self, slots, frozen):
         """
         Having one attribute works with auto_exc=True.
@@ -615,14 +610,9 @@
 
         FooError(1)
 
-    @pytest.mark.parametrize("slots", True, False)
-    @pytest.mark.parametrize("frozen", True, False)
     def test_eq_only(self, slots, frozen):
         """
         Classes with order=False cannot be ordered.
-
-        Python 3 throws a TypeError, in Python2 we have to check for the
-        absence.
         """
 
         @attr.s(eq=True, order=False, slots=slots, frozen=frozen)
@@ -640,7 +630,6 @@
 
         assert ei.value.args0 in possible_errors
 
-    @pytest.mark.parametrize("slots", True, False)
     @pytest.mark.parametrize("cmp", True, False)
     def test_attrib_cmp_shortcut(self, slots, cmp):
         """
@@ -654,7 +643,6 @@
         assert cmp is attr.fields(C).x.eq
         assert cmp is attr.fields(C).x.order
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_no_setattr_if_validate_without_validators(self, slots):
         """
         If a class has on_setattr=attr.setters.validate (former default in NG
@@ -664,11 +652,11 @@
         Regression test for #816.
         """
 
-        @attr.s(on_setattr=attr.setters.validate)
+        @attr.s(on_setattr=attr.setters.validate, slots=slots)
         class C:
             x = attr.ib()
 
-        @attr.s(on_setattr=attr.setters.validate)
+        @attr.s(on_setattr=attr.setters.validate, slots=slots)
         class D(C):
             y = attr.ib()
 
@@ -679,18 +667,17 @@
         assert "self.y = y" in src
         assert object.__setattr__ == D.__setattr__
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_no_setattr_if_convert_without_converters(self, slots):
         """
         If a class has on_setattr=attr.setters.convert but sets no validators,
         don't use the (slower) setattr in __init__.
         """
 
-        @attr.s(on_setattr=attr.setters.convert)
+        @attr.s(on_setattr=attr.setters.convert, slots=slots)
         class C:
             x = attr.ib()
 
-        @attr.s(on_setattr=attr.setters.convert)
+        @attr.s(on_setattr=attr.setters.convert, slots=slots)
         class D(C):
             y = attr.ib()
 
@@ -701,8 +688,6 @@
         assert "self.y = y" in src
         assert object.__setattr__ == D.__setattr__
 
-    @pytest.mark.skipif(not PY36, reason="NG APIs are 3.6+")
-    @pytest.mark.parametrize("slots", True, False)
     def test_no_setattr_with_ng_defaults(self, slots):
         """
         If a class has the NG default on_setattr=convert, validate but sets
@@ -710,7 +695,7 @@
         __init__.
         """
 
-        @attr.define
+        @attr.define(slots=slots)
         class C:
             x = attr.ib()
 
@@ -720,7 +705,7 @@
         assert "self.x = x" in src
         assert object.__setattr__ == C.__setattr__
 
-        @attr.define
+        @attr.define(slots=slots)
         class D(C):
             y = attr.ib()
 
@@ -747,6 +732,18 @@
 
         src = inspect.getsource(D.__init__)

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_hooks.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_hooks.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_init_subclass.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_init_subclass.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_make.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_make.py Changed

@@ -22,7 +22,7 @@
 import attr
 
 from attr import _config
-from attr._compat import PY310, ordered_dict
+from attr._compat import PY310
 from attr._make import (
     Attribute,
     Factory,
@@ -223,7 +223,7 @@
             "eq=True, eq_key=None, order=True, order_key=None, "
             "hash=None, init=True, "
             "metadata=mappingproxy({}), type=None, converter=None, "
-            "kw_only=False, inherited=False, on_setattr=None)",
+            "kw_only=False, inherited=False, on_setattr=None, alias=None)",
         ) == e.value.args
 
     def test_kw_only(self):
@@ -297,7 +297,7 @@
         b = attr.ib(default=2)
         a = attr.ib(default=1)
 
-        @attr.s(these=ordered_dict(("a", a), ("b", b)))
+        @attr.s(these=dict(("a", a), ("b", b)))
         class C:
             pass
 
@@ -571,7 +571,7 @@
     @given(slots_outer=booleans(), slots_inner=booleans())
     def test_repr_qualname(self, slots_outer, slots_inner):
         """
-        On Python 3, the name in repr is the __qualname__.
+        The name in repr is the __qualname__.
         """
 
         @attr.s(slots=slots_outer)
@@ -600,7 +600,7 @@
     @given(slots_outer=booleans(), slots_inner=booleans())
     def test_name_not_overridden(self, slots_outer, slots_inner):
         """
-        On Python 3, __name__ is different from __qualname__.
+        __name__ is different from __qualname__.
         """
 
         @attr.s(slots=slots_outer)
@@ -683,7 +683,6 @@
         assert str is fields(C).y.type
         assert None is fields(C).z.type
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_clean_class(self, slots):
         """
         Attribute definitions do not appear on the class body after @attr.s.
@@ -1043,7 +1042,6 @@
         assert D in cls.__mro__
         assert isinstance(cls(), D)
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_clean_class(self, slots):
         """
         Attribute definitions do not appear on the class body.
@@ -1071,7 +1069,7 @@
         b = attr.ib(default=2)
         a = attr.ib(default=1)
 
-        C = attr.make_class("C", ordered_dict(("a", a), ("b", b)))
+        C = attr.make_class("C", dict(("a", a), ("b", b)))
 
         assert "C(a=1, b=2)" == repr(C())
 
@@ -1114,7 +1112,7 @@
             fields(object)
 
         assert (
-            "{o!r} is not an attrs-decorated class.".format(o=object)
+            f"{object!r} is not an attrs-decorated class."
         ) == e.value.args0
 
     @given(simple_classes())
@@ -1156,7 +1154,7 @@
             fields_dict(object)
 
         assert (
-            "{o!r} is not an attrs-decorated class.".format(o=object)
+            f"{object!r} is not an attrs-decorated class."
         ) == e.value.args0
 
     @given(simple_classes())
@@ -1166,7 +1164,7 @@
         """
         d = fields_dict(C)
 
-        assert isinstance(d, ordered_dict)
+        assert isinstance(d, dict)
         assert list(fields(C)) == list(d.values())
         assert a.name for a in fields(C) == field_name for field_name in d
 
@@ -1214,7 +1212,7 @@
         """
         C = make_class(
             "C",
-            ordered_dict(
+            dict(
                 
                     ("y", attr.ib()),
                     (
@@ -1378,7 +1376,7 @@
 # Hypothesis seems to cache values, so the lists of attributes come out
 # unsorted.
 sorted_lists_of_attrs = list_of_attrs.map(
-    lambda l: sorted(l, key=attrgetter("counter"))
+    lambda ln: sorted(ln, key=attrgetter("counter"))
 )
 
 
@@ -1425,8 +1423,8 @@
                 a.metadata.setdefault(string, string)
 
             for k in a.metadata:
-                # For some reason, Python 3's MappingProxyType throws an
-                # IndexError for deletes on a large integer key.
+                # For some reason, MappingProxyType throws an IndexError for
+                # deletes on a large integer key.
                 with pytest.raises((TypeError, IndexError)):
                     del a.metadatak
                 with pytest.raises(AttributeError):
@@ -1732,6 +1730,107 @@
         assert actual == expected
 
 
+class TestInitAlias:
+    """
+    Tests for Attribute alias handling.
+    """
+
+    def test_default_and_specify(self):
+        """
+        alias is present on the Attributes returned from attr.fields.
+
+        If left unspecified, it defaults to standard private-attribute
+        handling.  If specified, it passes through the explicit alias.
+        """
+
+        # alias is None by default on _CountingAttr
+        default_counting = attr.ib()
+        assert default_counting.alias is None
+
+        override_counting = attr.ib(alias="specified")
+        assert override_counting.alias == "specified"
+
+        @attr.s
+        class Cases:
+            public_default = attr.ib()
+            _private_default = attr.ib()
+            __dunder_default__ = attr.ib()
+
+            public_override = attr.ib(alias="public")
+            _private_override = attr.ib(alias="_private")
+            __dunder_override__ = attr.ib(alias="__dunder__")
+
+        cases = attr.fields_dict(Cases)
+
+        # Default applies private-name mangling logic
+        assert cases"public_default".name == "public_default"
+        assert cases"public_default".alias == "public_default"
+
+        assert cases"_private_default".name == "_private_default"
+        assert cases"_private_default".alias == "private_default"
+
+        assert cases"__dunder_default__".name == "__dunder_default__"
+        assert cases"__dunder_default__".alias == "dunder_default__"
+
+        # Override is passed through
+        assert cases"public_override".name == "public_override"
+        assert cases"public_override".alias == "public"
+
+        assert cases"_private_override".name == "_private_override"
+        assert cases"_private_override".alias == "_private"
+
+        assert cases"__dunder_override__".name == "__dunder_override__"
+        assert cases"__dunder_override__".alias == "__dunder__"
+
+        # And aliases are applied to the __init__ signature
+        example = Cases(
+            public_default=1,
+            private_default=2,
+            dunder_default__=3,
+            public=4,
+            _private=5,
+            __dunder__=6,
+        )
+
+        assert example.public_default == 1
+        assert example._private_default == 2
+        assert example.__dunder_default__ == 3
+        assert example.public_override == 4
+        assert example._private_override == 5
+        assert example.__dunder_override__ == 6
+
+    def test_evolve(self):

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_mypy.yml -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_mypy.yml Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_next_gen.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_next_gen.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_pyright.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_pyright.py Changed

@@ -8,39 +8,48 @@
 
 import pytest
 
-import attr
+import attrs
 
 
-if sys.version_info < (3, 6):
-    _found_pyright = False
-else:
-    _found_pyright = shutil.which("pyright")
+pytestmark = 
+    pytest.mark.skipif(
+        sys.version_info < (3, 7), reason="Requires Python 3.7+."
+    ),
+    pytest.mark.skipif(
+        shutil.which("pyright") is None, reason="Requires pyright."
+    ),
+
 
 
-@attr.s(frozen=True)
+@attrs.frozen
 class PyrightDiagnostic:
-    severity = attr.ib()
-    message = attr.ib()
+    severity: str
+    message: str
 
 
-@pytest.mark.skipif(not _found_pyright, reason="Requires pyright.")
-def test_pyright_baseline():
-    """The __dataclass_transform__ decorator allows pyright to determine
-    attrs decorated class types.
-    """
-
-    test_file = os.path.dirname(__file__) + "/dataclass_transform_example.py"
-
+def parse_pyright_output(test_file):
     pyright = subprocess.run(
         "pyright", "--outputjson", str(test_file), capture_output=True
     )
+
     pyright_result = json.loads(pyright.stdout)
 
-    diagnostics = {
+    return {
         PyrightDiagnostic(d"severity", d"message")
         for d in pyright_result"generalDiagnostics"
     }
 
+
+def test_pyright_baseline():
+    """
+    The __dataclass_transform__ decorator allows pyright to determine attrs
+    decorated class types.
+    """
+
+    test_file = os.path.dirname(__file__) + "/dataclass_transform_example.py"
+
+    diagnostics = parse_pyright_output(test_file)
+
     # Expected diagnostics as per pyright 1.1.135
     expected_diagnostics = {
         PyrightDiagnostic(
@@ -66,6 +75,38 @@
             severity="information",
             message='Type of "d2.a" is "Literal\'new\'"',
         ),
+        PyrightDiagnostic(
+            severity="information",
+            message='Type of "af.__init__" is "(_a: int) -> None"',
+        ),
     }
 
+    assert expected_diagnostics == diagnostics
+
+
+def test_pyright_attrsinstance_compat(tmp_path):
+    """
+    Test that `AttrsInstance` is compatible with Pyright.
+    """
+    test_pyright_attrsinstance_compat_path = (
+        tmp_path / "test_pyright_attrsinstance_compat.py"
+    )
+    test_pyright_attrsinstance_compat_path.write_text(
+        """\
+import attrs
+
+# We can assign any old object to `AttrsInstance`.
+foo: attrs.AttrsInstance = object()
+
+reveal_type(attrs.AttrsInstance)
+"""
+    )
+
+    diagnostics = parse_pyright_output(test_pyright_attrsinstance_compat_path)
+    expected_diagnostics = {
+        PyrightDiagnostic(
+            severity="information",
+            message='Type of "attrs.AttrsInstance" is "TypeAttrsInstance"',
+        ),
+    }
     assert diagnostics == expected_diagnostics

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_setattr.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_setattr.py Changed

@@ -203,7 +203,6 @@
 
         assert "Frozen classes can't use on_setattr." == ei.value.args0
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_setattr_reset_if_no_custom_setattr(self, slots):
         """
         If a class with an active setattr is subclassed and no new setattr
@@ -229,7 +228,6 @@
         assert not NoHook.__attrs_own_setattr__
         assert WithOnSetAttrHook.__attrs_own_setattr__
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_setattr_inherited_do_not_reset(self, slots):
         """
         If we inherit a __setattr__ that has been written by the user, we must
@@ -257,7 +255,6 @@
 
         assert C.__setattr__ == A.__setattr__
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_pickling_retains_attrs_own(self, slots):
         """
         Pickling/Unpickling does not lose ownership information about
@@ -314,7 +311,6 @@
 
         C(1).x = 2
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_setattr_auto_detect_if_no_custom_setattr(self, slots):
         """
         It's possible to remove the on_setattr hook from an attribute and
@@ -334,7 +330,6 @@
         assert not RemoveNeedForOurSetAttr.__attrs_own_setattr__
         assert 2 == i.x
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_setattr_restore_respects_auto_detect(self, slots):
         """
         If __setattr__ should be restored but the user supplied its own and
@@ -348,7 +343,6 @@
 
         assert CustomSetAttr.__setattr__ != object.__setattr__
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_setattr_auto_detect_frozen(self, slots):
         """
         frozen=True together with a detected custom __setattr__ are rejected.
@@ -362,7 +356,6 @@
                 def __setattr__(self, _, __):
                     pass
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_setattr_auto_detect_on_setattr(self, slots):
         """
         on_setattr attributes together with a detected custom __setattr__ are
@@ -390,8 +383,8 @@
         A user-provided intermediate __setattr__ is not reset to
         object.__setattr__.
 
-        This only can work on Python 3+ with auto_detect activated, such that
-        attrs can know that there is a user-provided __setattr__.
+        This only can work with auto_detect activated, such that attrs can know
+        that there is a user-provided __setattr__.
         """
 
         @attr.s(slots=a_slots)

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_slots.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_slots.py Changed

@@ -9,6 +9,8 @@
 import types
 import weakref
 
+from unittest import mock
+
 import pytest
 
 import attr
@@ -452,7 +454,6 @@
         assert non_slot_instance.my_subclass() is C2
         assert slot_instance.my_subclass() is C2Slots
 
-    @pytest.mark.parametrize("slots", True, False)
     def test_cls_static(self, slots):
         """
         Slotted classes support proper closure cell rewriting for class- and
@@ -613,8 +614,8 @@
     closure cells are present with no contents in a `slots=True` class.
     (issue https://github.com/python-attrs/attrs/issues/589)
 
-    On Python 3, if a method mentions `__class__` or uses the no-arg `super()`,
-    the compiler will bake a reference to the class in the method itself as
+    If a method mentions `__class__` or uses the no-arg `super()`, the compiler
+    will bake a reference to the class in the method itself as
     `method.__closure__`. Since `attrs` replaces the class with a clone,
     `_ClassBuilder._create_slots_class(self)` will rewrite these references so
     it keeps working. This method was not properly covering the edge case where
@@ -725,7 +726,7 @@
 
 def test_slots_super_property_get_shortcut():
     """
-    On Python 3, the `super()` shortcut is allowed.
+    The `super()` shortcut is allowed.
     """
 
     @attr.s(slots=True)
@@ -744,3 +745,61 @@
 
     assert B(11).f == 121
     assert B(17).f == 289
+
+
+@attr.s(slots=True)
+class A:
+    x = attr.ib()
+    b = attr.ib()
+    c = attr.ib()
+
+
+@pytest.mark.parametrize("cls", A)
+def test_slots_unpickle_after_attr_removed(cls):
+    """
+    We don't assign attributes we don't have anymore if the class has
+    removed it.
+    """
+    a = cls(1, 2, 3)
+    a_pickled = pickle.dumps(a)
+    a_unpickled = pickle.loads(a_pickled)
+    assert a_unpickled == a
+
+    @attr.s(slots=True)
+    class NEW_A:
+        x = attr.ib()
+        c = attr.ib()
+
+    with mock.patch(f"{__name__}.A", NEW_A):
+        new_a = pickle.loads(a_pickled)
+
+        assert new_a.x == 1
+        assert new_a.c == 3
+        assert not hasattr(new_a, "b")
+
+
+@pytest.mark.parametrize("cls", A)
+def test_slots_unpickle_after_attr_added(cls, frozen):
+    """
+    We don't assign attribute we haven't had before if the class has one added.
+    """
+    a = cls(1, 2, 3)
+    a_pickled = pickle.dumps(a)
+    a_unpickled = pickle.loads(a_pickled)
+
+    assert a_unpickled == a
+
+    @attr.s(slots=True, frozen=frozen)
+    class NEW_A:
+        x = attr.ib()
+        b = attr.ib()
+        d = attr.ib()
+        c = attr.ib()
+
+    with mock.patch(f"{__name__}.A", NEW_A):
+        new_a = pickle.loads(a_pickled)
+
+        assert new_a.x == 1
+        assert new_a.b == 2
+        assert new_a.c == 3
+        assert not hasattr(new_a, "d")

_service:tar_scm:attrs-22.2.0.tar.gz/tests/test_utils.py Added

_service:tar_scm:attrs-22.1.0.tar.gz/tests/test_validators.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/test_validators.py Changed

@@ -14,6 +14,7 @@
 from attr import _config, fields, has
 from attr import validators as validator_module
 from attr.validators import (
+    _subclass_of,
     and_,
     deep_iterable,
     deep_mapping,
@@ -27,6 +28,7 @@
     matches_re,
     max_len,
     min_len,
+    not_,
     optional,
     provides,
 )
@@ -1064,3 +1066,278 @@
         __repr__ is meaningful.
         """
         assert repr(min_len(23)) == "<min_len validator for 23>"
+
+
+class TestSubclassOf:
+    """
+    Tests for `_subclass_of`.
+    """
+
+    def test_success(self):
+        """
+        Nothing happens if classes match.
+        """
+        v = _subclass_of(int)
+        v(None, simple_attr("test"), int)
+
+    def test_subclass(self):
+        """
+        Subclasses are accepted too.
+        """
+        v = _subclass_of(int)
+        # yep, bools are a subclass of int :(
+        v(None, simple_attr("test"), bool)
+
+    def test_fail(self):
+        """
+        Raises `TypeError` on wrong types.
+        """
+        v = _subclass_of(int)
+        a = simple_attr("test")
+        with pytest.raises(TypeError) as e:
+            v(None, a, str)
+        assert (
+            "'test' must be a subclass of <class 'int'> (got <class 'str'>).",
+            a,
+            int,
+            str,
+        ) == e.value.args
+
+    def test_repr(self):
+        """
+        Returned validator has a useful `__repr__`.
+        """
+        v = _subclass_of(int)
+        assert ("<subclass_of validator for type <class 'int'>>") == repr(v)
+
+
+class TestNot_:
+    """
+    Tests for `not_`.
+    """
+
+    DEFAULT_EXC_TYPES = (ValueError, TypeError)
+
+    def test_not_all(self):
+        """
+        The validator is in ``__all__``.
+        """
+        assert not_.__name__ in validator_module.__all__
+
+    def test_repr(self):
+        """
+        Returned validator has a useful `__repr__`.
+        """
+        wrapped = in_(3, 4, 5)
+
+        v = not_(wrapped)
+
+        assert (
+            (
+                "<not_ validator wrapping {wrapped!r}, "
+                "capturing {exc_types!r}>"
+            ).format(
+                wrapped=wrapped,
+                exc_types=v.exc_types,
+            )
+        ) == repr(v)
+
+    def test_success_because_fails(self):
+        """
+        If the wrapped validator fails, we're happy.
+        """
+
+        def always_fails(inst, attr, value):
+            raise ValueError("always fails")
+
+        v = not_(always_fails)
+        a = simple_attr("test")
+        input_value = 3
+
+        v(1, a, input_value)
+
+    def test_fails_because_success(self):
+        """
+        If the wrapped validator doesn't fail, not_ should fail.
+        """
+
+        def always_passes(inst, attr, value):
+            pass
+
+        v = not_(always_passes)
+        a = simple_attr("test")
+        input_value = 3
+
+        with pytest.raises(ValueError) as e:
+            v(1, a, input_value)
+
+        assert (
+            (
+                "not_ validator child '{!r}' did not raise a captured error"
+            ).format(always_passes),
+            a,
+            always_passes,
+            input_value,
+            self.DEFAULT_EXC_TYPES,
+        ) == e.value.args
+
+    def test_composable_with_in_pass(self):
+        """
+        Check something is ``not in`` something else.
+        """
+        v = not_(in_("abc"))
+        a = simple_attr("test")
+        input_value = "d"
+
+        v(None, a, input_value)
+
+    def test_composable_with_in_fail(self):
+        """
+        Check something is ``not in`` something else, but it is, so fail.
+        """
+        wrapped = in_("abc")
+        v = not_(wrapped)
+        a = simple_attr("test")
+        input_value = "b"
+
+        with pytest.raises(ValueError) as e:
+            v(None, a, input_value)
+
+        assert (
+            (
+                "not_ validator child '{!r}' did not raise a captured error"
+            ).format(in_("abc")),
+            a,
+            wrapped,
+            input_value,
+            self.DEFAULT_EXC_TYPES,
+        ) == e.value.args
+
+    def test_composable_with_matches_re_pass(self):
+        """
+        Check something does not match a regex.
+        """
+        v = not_(matches_re("a-z{3}"))
+        a = simple_attr("test")
+        input_value = "spam"
+
+        v(None, a, input_value)
+
+    def test_composable_with_matches_re_fail(self):
+        """
+        Check something does not match a regex, but it does, so fail.
+        """
+        wrapped = matches_re("a-z{3}")
+        v = not_(wrapped)
+        a = simple_attr("test")
+        input_value = "egg"
+
+        with pytest.raises(ValueError) as e:
+            v(None, a, input_value)
+
+        assert (
+            (
+                "not_ validator child '{!r}' did not raise a captured error"
+            ).format(wrapped),
+            a,
+            wrapped,
+            input_value,
+            self.DEFAULT_EXC_TYPES,
+        ) == e.value.args
+
+    def test_composable_with_instance_of_pass(self):

_service:tar_scm:attrs-22.1.0.tar.gz/tests/typing_example.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/typing_example.py Changed

@@ -119,6 +119,17 @@
     e.args
     str(e)
 
+# Field aliases
+
+
+@attrs.define
+class AliasExample:
+    without_alias: int
+    _with_alias: int = attr.ib(alias="_with_alias")
+
+
+attr.fields(AliasExample).without_alias.alias
+attr.fields(AliasExample)._with_alias.alias
 
 # Converters
 # XXX: Currently converters can only be functions so none of this works
@@ -206,6 +217,26 @@
         validator=attrs.validators.instance_of((int, C, str))
     )
 
+    l: Any = attr.ib(
+        validator=attr.validators.not_(attr.validators.in_("abc"))
+    )
+    m: Any = attr.ib(
+        validator=attr.validators.not_(
+            attr.validators.in_("abc"), exc_types=ValueError
+        )
+    )
+    n: Any = attr.ib(
+        validator=attr.validators.not_(
+            attr.validators.in_("abc"), exc_types=(ValueError,)
+        )
+    )
+    o: Any = attr.ib(
+        validator=attr.validators.not_(attr.validators.in_("abc"), msg="spam")
+    )
+    p: Any = attr.ib(
+        validator=attr.validators.not_(attr.validators.in_("abc"), msg=None)
+    )
+
 
 @attr.define
 class Validated2:
@@ -416,3 +447,13 @@
     attrs.setters.frozen
     attrs.validators.and_
     attrs.cmp_using
+
+
+foo = object
+if attrs.has(foo) or attr.has(foo):
+    foo.__attrs_attrs__
+
+
+@attrs.define(unsafe_hash=True)
+class Hashable:
+    pass

_service:tar_scm:attrs-22.1.0.tar.gz/tests/utils.py -> _service:tar_scm:attrs-22.2.0.tar.gz/tests/utils.py Changed

_service:tar_scm:attrs-22.1.0.tar.gz/tox.ini -> _service:tar_scm:attrs-22.2.0.tar.gz/tox.ini Changed

@@ -1,84 +1,75 @@
-pytest
-addopts = -ra
-testpaths = tests
-xfail_strict = true
-filterwarnings =
-    once::Warning
-    ignore:::pympler.*
-
-
 # Keep docs in sync with docs env and .readthedocs.yml.
 gh-actions
 python =
-    3.5: py35
-    3.6: py36
+    3.6: py36, mypy
     3.7: py37
     3.8: py38, changelog
-    3.9: py39, pyright
-    3.10: py310, manifest, typing, docs
+    3.9: py39
+    3.10: py310, mypy
     3.11: py311
+    3.12: py312
     pypy-3: pypy3
 
 
 tox
-envlist = typing,pre-commit,py35,py36,py37,py38,py39,py310,py311,pypy3,pyright,manifest,docs,pypi-description,changelog,coverage-report
+envlist = mypy,pre-commit,py36,py37,py38,py39,py310,py311,py312,pypy3,pyright,manifest,docs,pypi-description,changelog,coverage-report
 isolated_build = True
 
 
 testenv:docs
-# Keep basepython in sync with gh-actions and .readthedocs.yml.
+# Keep basepython in sync with ci.yml/docs and .readthedocs.yml.
 basepython = python3.10
 extras = docs
 commands =
     sphinx-build -n -T -W -b html -d {envtmpdir}/doctrees docs docs/_build/html
     sphinx-build -n -T -W -b doctest -d {envtmpdir}/doctrees docs docs/_build/html
-    python -m doctest README.rst
-
 
 testenv
 extras = tests
-commands = python -m pytest {posargs}
+commands = python -m pytest {posargs:-n auto}
 
 
-testenv:py35
-extras = tests
-commands = coverage run -m pytest {posargs}
+testenv:py36
+extras = cov
+setenv = COVERAGE_PROCESS_START={toxinidir}/pyproject.toml
+commands = coverage run -m pytest {posargs:-n auto}
 
 
-testenv:py37
-extras = tests
-commands = coverage run -m pytest {posargs}
+testenv:py310
+extras = cov
+setenv =
+    PYTHONWARNINGS=d
+    {testenv:py36setenv}
+commands = {testenv:py36commands}
 
 
-testenv:py310
+testenv:py31{1,2}
+extras = cov
 # Python 3.6+ has a number of compile-time warnings on invalid string escapes.
 # PYTHONWARNINGS=d and --no-compile below make them visible during the Tox run.
-basepython = python3.10
-install_command = pip install --no-compile {opts} {packages}
+install_command = python -m pip install --no-compile {opts} {packages}
 setenv =
     PYTHONWARNINGS=d
-extras = tests
+    {testenv:py36setenv}
+# xdist is currently broken on 3.11rc2
 commands = coverage run -m pytest {posargs}
 
 
 testenv:coverage-report
 basepython = python3.10
-depends = py35,py37,py310
+depends = py36,py310
 skip_install = true
-deps = coveragetoml>=5.4
+deps = coveragetoml>=5.3
 commands =
     coverage combine
     coverage report
 
 
 testenv:pre-commit
-basepython = python3.10
 skip_install = true
-deps =
-    pre-commit
+deps = pre-commit
 passenv = HOMEPATH  # needed on Windows
-commands =
-    pre-commit run --all-files
+commands = pre-commit run --all-files --show-diff-on-failure
 
 
 testenv:manifest
@@ -103,14 +94,13 @@
 basepython = python3.8
 deps = towncrier
 skip_install = true
-commands = towncrier --draft
+commands = towncrier build --version main --draft
 
 
-testenv:typing
-basepython = python3.10
+testenv:mypy
 deps = mypy>=0.902
 commands =
-    mypy src/attrs/__init__.pyi 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 src/attrs/__init__.pyi src/attr/__init__.pyi src/attr/_typing_compat.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
 
 
@@ -120,9 +110,23 @@
 # Use nodeenv to configure node in the running tox virtual environment
 # Seeing errors using "nodeenv -p"
 # Use npm install -g to install "globally" into the virtual environment
-basepython = python3.9
 deps = nodeenv
 commands =
     nodeenv --prebuilt --node=lts --force {envdir}
     npm install -g --no-package-lock --no-save pyright
     pytest tests/test_pyright.py -vv
+
+
+testenv:docset
+deps = doc2dash
+extras = docs
+allowlist_externals =
+    rm
+    cp
+    tar
+commands =
+    rm -rf attrs.docset attrs.tgz docs/_build
+    sphinx-build -n -T -W -b html -d {envtmpdir}/doctrees docs docs/_build/html
+    doc2dash --index-page index.html --icon docs/_static/docset-icon.png --online-redirect-url https://www.attrs.org/en/latest/ docs/_build/html
+    cp docs/_static/docset-icon@2x.png attrs.docset/icon@2x.png
+    tar --exclude='.DS_Store' -cvzf attrs.tgz attrs.docset