Metadata-Version: 1.1
Name: attrs
Version: 17.3.0
Summary: Classes Without Boilerplate
Home-page: http://www.attrs.org/
Author: Hynek Schlawack
Author-email: hs@ox.cx
License: MIT
Description-Content-Type: UNKNOWN
Description: .. image:: http://www.attrs.org/en/latest/_static/attrs_logo.png
           :alt: attrs Logo
        
        ======================================
        ``attrs``: Classes Without Boilerplate
        ======================================
        
        .. image:: https://readthedocs.org/projects/attrs/badge/?version=stable
           :target: http://www.attrs.org/en/stable/?badge=stable
           :alt: Documentation Status
        
        .. image:: https://travis-ci.org/python-attrs/attrs.svg?branch=master
           :target: https://travis-ci.org/python-attrs/attrs
           :alt: CI Status
        
        .. image:: https://codecov.io/github/python-attrs/attrs/branch/master/graph/badge.svg
           :target: https://codecov.io/github/python-attrs/attrs
           :alt: Test Coverage
        
        .. 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 <https://nedbatchelder.com/blog/200605/dunder.html>`_ methods).
        
        Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
        
        .. -spiel-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(default=attr.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,
        - an initializer,
        - and much more,
        
        *without* writing dull boilerplate code again and again and *without* runtime performance penalties.
        
        This gives you the power to use actual classes with actual types in your code instead of confusing ``tuple``\ s or `confusingly behaving <http://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.
        
        
        .. -testimonials-
        
        Testimonials
        ============
        
        **Amber Hawkie Brown**, Twisted Release Manager and Computer Owl:
        
          Writing a fully-functional class using attrs takes me less time than writing this testimonial.
        
        
        **Glyph Lefkowitz**, creator of `Twisted <https://twistedmatrix.com/>`_, `Automat <https://pypi.python.org/pypi/Automat>`_, and other open source software, in `The One Python Library Everyone Needs <https://glyph.twistedmatrix.com/2016/08/attrs.html>`_:
        
          I’m looking forward to is being able to program in Python-with-attrs everywhere.
          It exerts a subtle, but positive, design influence in all the codebases I’ve see it used in.
        
        
        **Kenneth Reitz**, author of `requests <http://www.python-requests.org/>`_, Python Overlord at Heroku, `on paper no less <https://twitter.com/hynek/status/866817877650751488>`_:
        
          attrs—classes for humans.  I like it.
        
        
        **Łukasz Langa**, prolific CPython core developer and Production Engineer at Facebook:
        
          I'm increasingly digging your attr.ocity. Good job!
        
        
        .. -end-
        
        .. -project-information-
        
        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 great way to help the project!
        
        
        Project Information
        ===================
        
        ``attrs`` is released under the `MIT <https://choosealicense.com/licenses/mit/>`_ license,
        its documentation lives at `Read the Docs <http://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.4+, and PyPy.
        
        If you'd like to contribute you're most welcome and we've written `a little guide <http://www.attrs.org/en/latest/contributing.html>`_ to get you started!
        
        
        Release Information
        ===================
        
        17.3.0 (2017-11-08)
        -------------------
        
        Backward-incompatible Changes
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        
        - Attributes are not defined on the class body anymore.
        
          This means that if you define a class ``C`` with an attribute ``x``, the class will *not* have an attribute ``x`` for introspection anymore.
          Instead of ``C.x``, use ``attr.fields(C).x`` or look at ``C.__attrs_attrs__``.
          The old behavior has been deprecated since version 16.1.
          (`#253 <https://github.com/python-attrs/attrs/issues/253>`_)
        
        
        Changes
        ^^^^^^^
        
        - ``super()`` and ``__class__`` now work on Python 3 when ``slots=True``.
          (`#102 <https://github.com/python-attrs/attrs/issues/102>`_, `#226 <https://github.com/python-attrs/attrs/issues/226>`_, `#269 <https://github.com/python-attrs/attrs/issues/269>`_, `#270 <https://github.com/python-attrs/attrs/issues/270>`_, `#272 <https://github.com/python-attrs/attrs/issues/272>`_)
        - Added ``type`` argument to ``attr.ib()`` and corresponding ``type`` attribute to ``attr.Attribute``.
        
          This change paves the way for automatic type checking and serialization (though as of this release ``attrs`` does not make use of it).
          In Python 3.6 or higher, the value of ``attr.Attribute.type`` can alternately be set using variable type annotations
          (see `PEP 526 <https://www.python.org/dev/peps/pep-0526/>`_). (`#151 <https://github.com/python-attrs/attrs/issues/151>`_, `#214 <https://github.com/python-attrs/attrs/issues/214>`_, `#215 <https://github.com/python-attrs/attrs/issues/215>`_, `#239 <https://github.com/python-attrs/attrs/issues/239>`_)
        - The combination of ``str=True`` and ``slots=True`` now works on Python 2.
          (`#198 <https://github.com/python-attrs/attrs/issues/198>`_)
        - ``attr.Factory`` is hashable again. (`#204
          <https://github.com/python-attrs/attrs/issues/204>`_)
        - Subclasses now can overwrite attribute definitions of their superclass.
        
          That means that you can -- for example -- change the default value for an attribute by redefining it.
          (`#221 <https://github.com/python-attrs/attrs/issues/221>`_, `#229 <https://github.com/python-attrs/attrs/issues/229>`_)
        - Added new option ``auto_attribs`` to ``@attr.s`` that allows to collect annotated fields without setting them to ``attr.ib()``.
        
          Setting a field to an ``attr.ib()`` is still possible to supply options like validators.
          Setting it to any other value is treated like it was passed as ``attr.ib(default=value)`` -- passing an instance of ``attr.Factory`` also works as expected.
          (`#262 <https://github.com/python-attrs/attrs/issues/262>`_, `#277 <https://github.com/python-attrs/attrs/issues/277>`_)
        - Instances of classes created using ``attr.make_class()`` can now be pickled.
          (`#282 <https://github.com/python-attrs/attrs/issues/282>`_)
        
        `Full changelog <http://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 `sub-classing 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.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Software Development :: Libraries :: Python Modules
