Metadata-Version: 1.1
Name: flake8-comprehensions
Version: 1.4.1
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
Description: =====================
        flake8-comprehensions
        =====================
        
        .. image:: https://img.shields.io/pypi/v/flake8-comprehensions.svg
                :target: https://pypi.python.org/pypi/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.
        
        * Free software: ISC license
        
        Installation
        ------------
        
        Install from ``pip`` with:
        
        .. code-block:: sh
        
             pip install flake8-comprehensions
        
        It will then automatically be run as part of ``flake8``; you can check it has
        been 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
        
        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.
        
Keywords: f,l,a,k,e,8,,, ,c,o,m,p,r,e,h,e,n,s,i,o,n,s,,, ,l,i,s,t, ,c,o,m,p,r,e,h,e,n,s,i,o,n,,, ,s,e,t, ,c,o,m,p,r,e,h,e,n,s,i,o,n,,, ,d,i,c,t, ,c,o,m,p,r,e,h,e,n,s,i,o,n
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: ISC License (ISCL)
Classifier: Natural Language :: English
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
