Metadata-Version: 2.1
Name: flake8-comprehensions
Version: 2.0.0
Summary: A flake8 plugin to help you write better list/set/dict comprehensions.
Home-page: https://github.com/adamchainz/flake8-comprehensions
Author: Adam Johnson
Author-email: me@adamj.eu
License: ISCL
Keywords: flake8,comprehensions,list comprehension,set comprehension,dict comprehension
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Framework :: Flake8
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: ISC License (ISCL)
Classifier: Natural Language :: English
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 :: 3.7
Requires-Python: >=3.4
Requires-Dist: flake8 (!=3.2.0)

=====================
flake8-comprehensions
=====================

.. image:: https://img.shields.io/pypi/v/flake8-comprehensions.svg
        :target: https://pypi.org/project/flake8-comprehensions/

.. image:: https://img.shields.io/travis/adamchainz/flake8-comprehensions.svg
        :target: https://travis-ci.org/adamchainz/flake8-comprehensions

A `flake8 <https://flake8.readthedocs.io/en/latest/index.html>`_ plugin that
helps you write better list/set/dict comprehensions.

Installation
------------

Install from ``pip`` with:

.. code-block:: sh

     pip install flake8-comprehensions

Python 3.4+ supported.

When installed it will automatically be run as part of ``flake8``; you can
check it is being picked up with:

.. code-block:: sh

    $ flake8 --version
    2.4.1 (pep8: 1.7.0, pyflakes: 0.8.1, flake8-comprehensions: 1.0.0, mccabe: 0.3.1) CPython 2.7.11 on Darwin


Rules
-----

==== ====
Code Rule
==== ====
C400 Unnecessary generator - rewrite as a list comprehension.
C401 Unnecessary generator - rewrite as a set comprehension.
C402 Unnecessary generator - rewrite as a dict comprehension.
C403 Unnecessary list comprehension - rewrite as a set comprehension.
C404 Unnecessary list comprehension - rewrite as a dict comprehension.
C405 Unnecessary (list/tuple) literal - rewrite as a set literal.
C406 Unnecessary (list/tuple) literal - rewrite as a dict literal.
C407 Unnecessary list comprehension - '<builtin>' can take a generator.
C408 Unnecessary (dict/list/tuple) call - rewrite as a literal.
C409 Unnecessary (list/tuple) passed to tuple() - (remove the outer call to tuple()/rewrite as a tuple literal).
C410 Unnecessary (list/tuple) passed to list() - (remove the outer call to list()/rewrite as a list literal).
C411 Unnecessary list call - remove the outer call to list().
==== ====

Examples
--------

C400-402: Unnecessary generator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It's unnecessary to use ``list``, ``set``, or ``dict`` around a generator
expression, since there are equivalent comprehensions for these types. For
example:

* ``list(f(x) for x in foo)`` is better as ``[f(x) for x in foo]``
* ``set(f(x) for x in foo)`` is better as ``{f(x) for x in foo}``
* ``dict((x, f(x)) for x in foo)`` is better as ``{x: f(x) for x in foo}``

C403-404: Unnecessary list comprehension
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It's unnecessary to use a list comprehension inside a call to ``set`` or
``dict``, since there are equivalent comprehensions for these types. For
example:

* ``set([f(x) for x in foo])`` is better as ``{f(x) for x in foo}``
* ``dict([(x, f(x)) for x in foo])`` is better as ``{x: f(x) for x in foo}``

C405-406,C409-410: Unnecessary list/tuple literal
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It's unnecessary to use a list or tuple literal within a call to ``tuple``,
``list``, ``set``, or ``dict`` since there is literal syntax for these types.
For example:

* ``tuple([1, 2])`` and ``tuple((1, 2))`` are better as ``(1, 2)``
* ``tuple([])`` is better as ``()``
* ``list([1, 2])`` and ``list((1, 2))`` are better as ``[1, 2]``
* ``list([])`` is better as ``[]``
* ``set([1, 2])`` and ``set((1, 2))`` are better as ``{1, 2}``
* ``set([])`` is better as ``set()``
* ``dict([(1, 2)])`` and ``dict(((1, 2),))`` are better as ``{1: 2}``
* ``dict([])`` is better as ``{}``

C407: Unnecessary list comprehension - '<builtin>' can take a generator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It's unnecessary to pass a list comprehension to some builtins that can take
generators instead. For example:

* ``sum([x ** 2 for x in range(10)])`` is better as
  ``sum(x ** 2 for x in range(10))``
* ``all([foo.bar for foo in foos])`` is better as
  ``all(foo.bar for foo in foos)``

The list of builtins that are checked for are:

* ``all``
* ``any``
* ``frozenset``
* ``max``
* ``min``
* ``sorted``
* ``sum``
* ``tuple``

C408: Unnecessary (dict/list/tuple) call - rewrite as a literal.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It's slower to call e.g. ``dict()`` than using the empty literal, because the
name ``dict`` must be looked up in the global scope in case it has been
rebound. Same for the other two basic types here. For example:

* ``dict()`` is better as ``{}``
* ``list()`` is better as ``[]``
* ``tuple()`` is better as ``()``

C411: Unnecessary list call - remove the outer call to list().
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It's unnecessary to use a ``list`` around list comprehension, since it is
equivalent without it. For example:

* ``list([f(x) for x in foo])`` is better as ``[f(x) for x in foo]``


=======
History
=======

Pending Release
---------------

.. Insert new release notes below this line

2.0.0 (2019-02-02)
------------------

* Drop Python 2 support, only Python 3.4+ is supported now.

1.4.1 (2017-05-17)
------------------

* Fix false positives in ``C408`` for calls using ``*args`` or ``**kwargs``.

1.4.0 (2017-05-14)
------------------

* Plugin now reserves the full ``C4XX`` code space rather than just ``C40X``
* ``C408`` rule that complains about using ``tuple()``, ``list()``, or
  ``dict()`` instead of a literal.
* ``C409`` and ``C410`` rules that complain about an unnecessary list or tuple
  that could be rewritten as a literal.
* ``C411`` rule that complains about using list comprehension inside a
  ``list()`` call.

1.3.0 (2017-05-01)
------------------

* Don't allow installation with Flake8 3.2.0 which doesn't enable the plugin.
  This bug was fixed in Flake8 3.2.1.
* Prevent false positives of ``C402`` from generators of expressions that
  aren't two-tuples.
* ``C405`` and ``C406`` now also complain about unnecessary tuple literals.

1.2.1 (2016-06-27)
------------------

* ``C407`` rule that complains about unnecessary list comprehensions inside
  builtins that can work on generators.

1.2.0 (2016-07-11)
------------------

* Split all rule codes by type. This allows granular selection of the rules in
  flake8 configuration.

1.1.1 (2016-04-06)
------------------

* Fix crash on method calls

1.1.0 (2016-04-06)
------------------

* ``C401`` rule that complains about unnecessary list comprehensions inside
  calls to ``set()`` or ``dict()``.
* ``C402`` rule that complains about unnecessary list literals inside calls to
  ``set()`` or ``dict()``.

1.0.0 (2016-04-05)
------------------

* ``C400`` rule that complains about an unnecessary usage of a generator when a
  list/set/dict comprehension would do.


