Metadata-Version: 2.1
Name: attrs
Version: 21.1.0
Summary: Classes Without Boilerplate
Home-page: https://www.attrs.org/
Author: Hynek Schlawack
Author-email: hs@ox.cx
Maintainer: Hynek Schlawack
Maintainer-email: hs@ox.cx
License: MIT
Project-URL: Documentation, https://www.attrs.org/
Project-URL: Changelog, https://www.attrs.org/en/stable/changelog.html
Project-URL: Bug Tracker, https://github.com/python-attrs/attrs/issues
Project-URL: Source Code, https://github.com/python-attrs/attrs
Project-URL: Funding, https://github.com/sponsors/hynek
Project-URL: Tidelift, https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=pypi
Project-URL: Ko-fi, https://ko-fi.com/the_hynek
Description: ======================================
        ``attrs``: Classes Without Boilerplate
        ======================================
        
        
        ``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 <https://nedbatchelder.com/blog/200605/dunder.html>`_ methods).
        `Trusted by NASA <https://docs.github.com/en/github/setting-up-and-managing-your-github-profile/personalizing-your-profile#list-of-qualifying-repositories-for-mars-2020-helicopter-contributor-badge>`_ 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
        
           >>> import attr
        
           >>> @attr.s
           ... class SomeClass(object):
           ...     a_number = attr.ib(default=42)
           ...     list_of_numbers = attr.ib(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
        
           >>> attr.asdict(sc)
           {'a_number': 1, 'list_of_numbers': [1, 2, 3]}
        
           >>> SomeClass()
           SomeClass(a_number=42, list_of_numbers=[])
        
           >>> C = attr.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__``,
        - a complete set of comparison methods (equality and ordering),
        - an initializer,
        - and much more,
        
        *without* writing dull boilerplate code again and again and *without* runtime performance penalties.
        
        On Python 3.6 and later, you can often even drop the calls to ``attr.ib()`` by using `type annotations <https://www.attrs.org/en/latest/types.html>`_.
        
        This gives you the power to use actual classes with actual types in your code instead of confusing ``tuple``\ s or `confusingly behaving <https://www.attrs.org/en/stable/why.html#namedtuples>`_ ``namedtuple``\ s.
        Which in turn encourages you to write *small classes* that do `one thing well <https://www.destroyallsoftware.com/talks/boundaries>`_.
        Never again violate the `single responsibility principle <https://en.wikipedia.org/wiki/Single_responsibility_principle>`_ just because implementing ``__init__`` et al is a painful drag.
        
        
        .. -getting-help-
        
        Getting Help
        ============
        
        Please use the ``python-attrs`` tag on `StackOverflow <https://stackoverflow.com/questions/tagged/python-attrs>`_ to get help.
        
        Answering questions of your fellow developers is also a great way to help the project!
        
        
        .. -project-information-
        
        Project Information
        ===================
        
        ``attrs`` is released under the `MIT <https://choosealicense.com/licenses/mit/>`_ license,
        its documentation lives at `Read the Docs <https://www.attrs.org/>`_,
        the code on `GitHub <https://github.com/python-attrs/attrs>`_,
        and the latest release on `PyPI <https://pypi.org/project/attrs/>`_.
        It’s rigorously tested on Python 2.7, 3.5+, and PyPy.
        
        We collect information on **third-party extensions** in our `wiki <https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs>`_.
        Feel free to browse and add your own!
        
        If you'd like to contribute to ``attrs`` you're most welcome and we've written `a little guide <https://www.attrs.org/en/latest/contributing.html>`_ 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>`_
        
        
        Release Information
        ===================
        
        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 <https://www.attrs.org/en/stable/api.html#next-gen>`_ 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>`_.
        
          We hope the next release will already contain an (additional) importable package called ``attrs``.
          `#668 <https://github.com/python-attrs/attrs/issues/668>`_,
          `#786 <https://github.com/python-attrs/attrs/issues/786>`_
        - If an attribute defines a converter, the type of its parameter is used as type annotation for its corresponding ``__init__`` parameter.
        
          If an ``attr.converters.pipe`` is used, the first one's is used.
          `#710 <https://github.com/python-attrs/attrs/issues/710>`_
        - Fixed the creation of an extra slot for an ``attr.ib`` when the parent class already has a slot with the same name.
          `#718 <https://github.com/python-attrs/attrs/issues/718>`_
        - ``__attrs__init__()`` will now be injected if ``init=False``, or if ``auto_detect=True`` and a user-defined ``__init__()`` exists.
        
          This enables users to do "pre-init" work in their ``__init__()`` (such as ``super().__init__()``).
        
          ``__init__()`` can then delegate constructor argument processing to ``self.__attrs_init__(*args, **kwargs)``.
          `#731 <https://github.com/python-attrs/attrs/issues/731>`_
        - ``bool(attr.NOTHING)`` is now ``False``.
          `#732 <https://github.com/python-attrs/attrs/issues/732>`_
        - It's now possible to use ``super()`` inside of properties of slotted classes.
          `#747 <https://github.com/python-attrs/attrs/issues/747>`_
        - Allow for a ``__attrs_pre_init__()`` method that -- if defined -- will get called at the beginning of the ``attrs``-generated ``__init__()`` method.
          `#750 <https://github.com/python-attrs/attrs/issues/750>`_
        - Added forgotten ``attr.Attribute.evolve()`` to type stubs.
          `#752 <https://github.com/python-attrs/attrs/issues/752>`_
        - ``attrs.evolve()`` now works recursively with nested ``attrs`` classes.
          `#759 <https://github.com/python-attrs/attrs/issues/759>`_
        - Python 3.10 is now officially supported.
          `#763 <https://github.com/python-attrs/attrs/issues/763>`_
        - ``attr.resolve_types()`` now takes an optional *attrib* argument to work inside a ``field_transformer``.
          `#774 <https://github.com/python-attrs/attrs/issues/774>`_
        - ``ClassVar``\ s are now also detected if they come from `typing-extensions <https://pypi.org/project/typing-extensions/>`_.
          `#782 <https://github.com/python-attrs/attrs/issues/782>`_
        - To make it easier to customize attribute comparison (#435), we have added the ``attr.cmp_with()`` helper.
        
          See the `new docs on comparison <https://www.attrs.org/en/stable/comparison.html>`_ for more details.
          `#787 <https://github.com/python-attrs/attrs/issues/787>`_
        - Added **provisional** support for static typing in ``pyright`` via the `dataclass_transforms specification <https://github.com/microsoft/pyright/blob/master/specs/dataclass_transforms.md>`_.
          Both the ``pyright`` specification and ``attrs`` implementation may change in future versions of both projects.
        
          Your constructive feedback is welcome in both `attrs#795 <https://github.com/python-attrs/attrs/issues/795>`_ and `pyright#1782 <https://github.com/microsoft/pyright/discussions/1782>`_.
          `#796 <https://github.com/python-attrs/attrs/issues/796>`_
        
        `Full changelog <https://www.attrs.org/en/stable/changelog.html>`_.
        
        Credits
        =======
        
        ``attrs`` is written and maintained by `Hynek Schlawack <https://hynek.me/>`_.
        
        The development is kindly supported by `Variomedia AG <https://www.variomedia.de/>`_.
        
        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://twistedmatrix.com/documents/current/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?
        
Keywords: class,attribute,boilerplate
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Description-Content-Type: text/x-rst
Provides-Extra: docs
Provides-Extra: tests_no_zope
Provides-Extra: tests
Provides-Extra: dev
