%define scl rh-python36 %{?scl:%scl_package %{name}} %{!?scl:%global pkg_name %{name}} %define name attrs %define version 19.1.0 %define unmangled_version 19.1.0 %define unmangled_version 19.1.0 %define release 1 Summary: Classes Without Boilerplate %{?scl:Requires: %{scl}-runtime} %{?scl:BuildRequires: %{scl}-runtime} Name: %{?scl_prefix}%{pkg_name} Version: %{version} Release: %{release} Source0: attrs-%{unmangled_version}.tar.gz License: MIT Group: Development/Libraries BuildRoot: %{_tmppath}/%{pkg_name}-%{version}-%{release}-buildroot Prefix: %{_prefix} BuildArch: noarch Vendor: Hynek Schlawack Packager: Martin Juhl Url: http://www.attrs.org/ %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 `_ 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 `_ ``namedtuple``\ s. Which in turn encourages you to write *small classes* that do `one thing well `_. Never again violate the `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 `_, `Automat `_, and other open source software, in `The One Python Library Everyone Needs `_: 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 `_, Python Overlord at Heroku, `on paper no less `_: 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 `_ 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 `_ license, its documentation lives at `Read the Docs `_, the code on `GitHub `_, and the latest release on `PyPI `_. 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 `_ to get you started! Release Information =================== 17.4.0 (2017-12-30) ------------------- Backward-incompatible Changes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - The traversal of MROs when using multiple inheritance was backward: If you defined a class ``C`` that subclasses ``A`` and ``B`` like ``C(A, B)``, ``attrs`` would have collected the attributes from ``B`` *before* those of ``A``. This is now fixed and means that in classes that employ multiple inheritance, the output of ``__repr__`` and the order of positional arguments in ``__init__`` changes. Due to the nature of this bug, a proper deprecation cycle was unfortunately impossible. Generally speaking, it's advisable to prefer ``kwargs``-based initialization anyways – *especially* if you employ multiple inheritance and diamond-shaped hierarchies. `#298 `_, `#299 `_, `#304 `_ - The ``__repr__`` set by ``attrs`` no longer produces an ``AttributeError`` when the instance is missing some of the specified attributes (either through deleting or after using ``init=False`` on some attributes). This can break code that relied on ``repr(attr_cls_instance)`` raising ``AttributeError`` to check if any attr-specified members were unset. If you were using this, you can implement a custom method for checking this:: def has_unset_members(self): for field in attr.fields(type(self)): try: getattr(self, field.name) except AttributeError: return True return False `#308 `_ Deprecations ^^^^^^^^^^^^ - The ``attr.ib(convert=callable)`` option is now deprecated in favor of ``attr.ib(converter=callable)``. This is done to achieve consistency with other noun-based arguments like *validator*. *convert* will keep working until at least January 2019 while raising a ``DeprecationWarning``. `#307 `_ Changes ^^^^^^^ - Generated ``__hash__`` methods now hash the class type along with the attribute values. Until now the hashes of two classes with the same values were identical which was a bug. The generated method is also *much* faster now. `#261 `_, `#295 `_, `#296 `_ - ``attr.ib``\ ’s ``metadata`` argument now defaults to a unique empty ``dict`` instance instead of sharing a common empty ``dict`` for all. The singleton empty ``dict`` is still enforced. `#280 `_ - ``ctypes`` is optional now however if it's missing, a bare ``super()`` will not work in slots classes. This should only happen in special environments like Google App Engine. `#284 `_, `#286 `_ - The attribute redefinition feature introduced in 17.3.0 now takes into account if an attribute is redefined via multiple inheritance. In that case, the definition that is closer to the base of the class hierarchy wins. `#285 `_, `#287 `_ - Subclasses of ``auto_attribs=True`` can be empty now. `#291 `_, `#292 `_ - Equality tests are *much* faster now. `#306 `_ - All generated methods now have correct ``__module__``, ``__name__``, and (on Python 3) ``__qualname__`` attributes. `#309 `_ `Full changelog `_. Credits ======= ``attrs`` is written and maintained by `Hynek Schlawack `_. The development is kindly supported by `Variomedia AG `_. A full list of contributors can be found in `GitHub's overview `_. It’s the spiritual successor of `characteristic `_ and aspires to fix some of it clunkiness and unfortunate decisions. Both were inspired by Twisted’s `FancyEqMixin `_ but both are implemented using class decorators because `sub-classing is bad for you `_, m’kay? %prep %{?scl:scl enable %{scl} - << \EOF} set -ex %setup -n attrs-%{unmangled_version} -n attrs-%{unmangled_version} %{?scl:EOF} %build %{?scl:scl enable %{scl} - << \EOF} set -ex python3 setup.py build %{?scl:EOF} %install %{?scl:scl enable %{scl} - << \EOF} set -ex python3 setup.py install --single-version-externally-managed -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILES %{?scl:EOF} %clean %{?scl:scl enable %{scl} - << \EOF} set -ex rm -rf $RPM_BUILD_ROOT %{?scl:EOF} %files -f INSTALLED_FILES %defattr(-,root,root)