{"author":null,"author_email":"Adam Johnson ","bugtrack_url":null,"classifiers":["Development Status :: 5 - Production/Stable","Framework :: Flake8","Intended Audience :: Developers","License :: OSI Approved :: MIT License","Natural Language :: English","Programming Language :: Python :: 3 :: Only","Programming Language :: Python :: 3.10","Programming Language :: Python :: 3.11","Programming Language :: Python :: 3.12","Programming Language :: Python :: 3.13","Programming Language :: Python :: 3.9","Typing :: Typed"],"description":"=====================\nflake8-comprehensions\n=====================\n\n.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/flake8-comprehensions/main.yml.svg?branch=main&style=for-the-badge\n :target: https://github.com/adamchainz/flake8-comprehensions/actions?workflow=CI\n\n.. image:: https://img.shields.io/pypi/v/flake8-comprehensions.svg?style=for-the-badge\n :target: https://pypi.org/project/flake8-comprehensions/\n\n.. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge\n :target: https://github.com/psf/black\n\n.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge\n :target: https://github.com/pre-commit/pre-commit\n :alt: pre-commit\n\nA `flake8 `_ plugin that helps you write better list/set/dict comprehensions.\n\n----\n\n**Linting a Django project?**\nCheck out my book `Boost Your Django DX `__ which covers Flake8 and many other code quality tools.\n\n----\n\nRequirements\n============\n\nPython 3.9 to 3.13 supported.\n\nInstallation\n============\n\nFirst, install with ``pip``:\n\n.. code-block:: sh\n\n python -m pip install flake8-comprehensions\n\nSecond, if you define Flake8’s ``select`` setting, add the ``C4`` prefix to it.\nOtherwise, the plugin should be active by default.\n\nRules\n=====\n\nC400-402: Unnecessary generator - rewrite as a ```` comprehension.\n---------------------------------------------------------------------------------\n\nRules:\n\n* C400 Unnecessary generator - rewrite as a list comprehension.\n* C401 Unnecessary generator - rewrite as a set comprehension.\n* C402 Unnecessary generator - rewrite as a dict comprehension.\n\nIt's unnecessary to use ``list``, ``set``, or ``dict`` around a generator expression, since there are equivalent comprehensions for these types.\nFor example:\n\n* Rewrite ``list(f(x) for x in foo)`` as ``[f(x) for x in foo]``\n* Rewrite ``set(f(x) for x in foo)`` as ``{f(x) for x in foo}``\n* Rewrite ``dict((x, f(x)) for x in foo)`` as ``{x: f(x) for x in foo}``\n\nC403-404: Unnecessary list comprehension - rewrite as a ```` comprehension.\n-------------------------------------------------------------------------------------\n\nRules:\n\n* C403 Unnecessary list comprehension - rewrite as a set comprehension.\n* C404 Unnecessary list comprehension - rewrite as a dict comprehension.\n\nIt's unnecessary to use a list comprehension inside a call to ``set`` or ``dict``, since there are equivalent comprehensions for these types.\nFor example:\n\n* Rewrite ``set([f(x) for x in foo])`` as ``{f(x) for x in foo}``\n* Rewrite ``dict([(x, f(x)) for x in foo])`` as ``{x: f(x) for x in foo}``\n\nC405-406: Unnecessary ```` literal - rewrite as a ```` literal.\n-------------------------------------------------------------------------------------\n\n* C405 Unnecessary ```` literal - rewrite as a set literal.\n* C406 Unnecessary ```` literal - rewrite as a dict literal.\n\nIt's unnecessary to use a list or tuple literal within a call to ``set`` or ``dict``.\nFor example:\n\n* Rewrite ``set([1, 2])`` as ``{1, 2}``\n* Rewrite ``set((1, 2))`` as ``{1, 2}``\n* Rewrite ``set([])`` as ``set()``\n* Rewrite ``dict([(1, 2)])`` as ``{1: 2}``\n* Rewrite ``dict(((1, 2),))`` as ``{1: 2}``\n* Rewrite ``dict([])`` as ``{}``\n\nC407: Unnecessary ```` comprehension - ```` can take a generator\n------------------------------------------------------------------------------------\n\nThis rule was dropped in version 3.4.0, because it promoted an increase in laziness which could lead to bugs.\n\nC408: Unnecessary ```` call - rewrite as a literal.\n--------------------------------------------------------------------\n\nIt'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.\nSame for the other two basic types here.\nFor example:\n\n* Rewrite ``dict()`` as ``{}``\n* Rewrite ``dict(a=1, b=2)`` as ``{\"a\": 1, \"b\": 2}``\n* Rewrite ``list()`` as ``[]``\n* Rewrite ``tuple()`` as ``()``\n\nC409-410: Unnecessary ```` passed to ````\\() - ````.\n------------------------------------------------------------------------------------\n\nRules:\n\n* C409 Unnecessary ```` passed to tuple() - ````.\n* C410 Unnecessary list passed to list() - ````.\n\nWhere ```` is either:\n\n* remove the outer call to ````\\()\n* rewrite as a ```` literal\n\nIt's unnecessary to use a list or tuple literal within a call to ``list`` or ``tuple``, since there is literal syntax for these types.\nFor example:\n\n* Rewrite ``tuple([1, 2])`` as ``(1, 2)``\n* Rewrite ``tuple((1, 2))`` as ``(1, 2)``\n* Rewrite ``tuple([])`` as ``()``\n* Rewrite ``list([1, 2])`` as ``[1, 2]``\n* Rewrite ``list((1, 2))`` as ``[1, 2]``\n* Rewrite ``list([])`` as ``[]``\n\nC411: Unnecessary list call - remove the outer call to list().\n--------------------------------------------------------------\n\nIt's unnecessary to use a ``list`` around a list comprehension, since it is equivalent without it.\nFor example:\n\n* Rewrite ``list([f(x) for x in foo])`` as ``[f(x) for x in foo]``\n\nC412: Unnecessary ```` comprehension - 'in' can take a generator.\n--------------------------------------------------------------------------------\n\nThis rule was dropped in version 3.4.0, because it promoted an increase in laziness which could lead to bugs.\n\nC413: Unnecessary ```` call around sorted().\n-----------------------------------------------------------\n\nIt's unnecessary to use ``list()`` around ``sorted()`` as it already returns a list.\nIt is also unnecessary to use ``reversed()`` around ``sorted()`` as the latter has a ``reverse`` argument.\nFor example:\n\n* Rewrite ``list(sorted([2, 3, 1]))`` as ``sorted([2, 3, 1])``\n* Rewrite ``reversed(sorted([2, 3, 1]))`` as ``sorted([2, 3, 1], reverse=True)``\n* Rewrite ``reversed(sorted([2, 3, 1], reverse=True))`` as ``sorted([2, 3, 1])``\n\nC414: Unnecessary ```` call within ````\\().\n--------------------------------------------------------------------------------------------------\n\nIt's unnecessary to double-cast or double-process iterables by wrapping the listed functions within ``list``/``set``/``sorted``/``tuple``.\nFor example:\n\n* Rewrite ``list(list(iterable))`` as ``list(iterable)``\n* Rewrite ``list(tuple(iterable))`` as ``list(iterable)``\n* Rewrite ``tuple(list(iterable))`` as ``tuple(iterable)``\n* Rewrite ``tuple(tuple(iterable))`` as ``tuple(iterable)``\n* Rewrite ``set(set(iterable))`` as ``set(iterable)``\n* Rewrite ``set(list(iterable))`` as ``set(iterable)``\n* Rewrite ``set(tuple(iterable))`` as ``set(iterable)``\n* Rewrite ``set(sorted(iterable))`` as ``set(iterable)``\n* Rewrite ``set(reversed(iterable))`` as ``set(iterable)``\n* Rewrite ``sorted(list(iterable))`` as ``sorted(iterable)``\n* Rewrite ``sorted(tuple(iterable))`` as ``sorted(iterable)``\n* Rewrite ``sorted(sorted(iterable))`` as ``sorted(iterable)``\n* Rewrite ``sorted(reversed(iterable))`` as ``sorted(iterable)``\n\nC415: Unnecessary subscript reversal of iterable within ````\\().\n-------------------------------------------------------------------------------------\n\nIt's unnecessary to reverse the order of an iterable when passing it into one of the listed functions will change the order again.\nFor example:\n\n* Rewrite ``set(iterable[::-1])`` as ``set(iterable)``\n* Rewrite ``sorted(iterable)[::-1]`` as ``sorted(iterable, reverse=True)``\n* Rewrite ``reversed(iterable[::-1])`` as ``iterable``\n\nC416: Unnecessary ```` comprehension - rewrite using ````\\().\n-------------------------------------------------------------------------------------------\n\nIt's unnecessary to use a dict/list/set comprehension to build a data structure if the elements are unchanged.\nWrap the iterable with ``dict()``, ``list()``, or ``set()`` instead.\nFor example:\n\n* Rewrite ``{a: b for a, b in iterable}`` as ``dict(iterable)``\n* Rewrite ``[x for x in iterable]`` as ``list(iterable)``\n* Rewrite ``{x for x in iterable}`` as ``set(iterable)``\n\nC417: Unnecessary ``map`` usage - rewrite using a generator expression/```` comprehension.\n---------------------------------------------------------------------------------------------------------\n\n``map(func, iterable)`` has great performance when ``func`` is a built-in function, and it makes sense if your function already has a name.\nBut if your func is a ``lambda``, it’s faster to use a generator expression or a comprehension, as it avoids the function call overhead.\nFor example:\n\n* Rewrite ``map(lambda x: x + 1, iterable)`` to ``(x + 1 for x in iterable)``\n* Rewrite ``map(lambda item: get_id(item), items)`` to ``(get_id(item) for item in items)``\n* Rewrite ``list(map(lambda num: num * 2, nums))`` to ``[num * 2 for num in nums]``\n* Rewrite ``set(map(lambda num: num % 2 == 0, nums))`` to ``{num % 2 == 0 for num in nums}``\n* Rewrite ``dict(map(lambda v: (v, v ** 2), values))`` to ``{v : v ** 2 for v in values}``\n\nC418: Unnecessary ```` passed to dict() - remove the outer call to dict()\n--------------------------------------------------------------------------------------------------\n\nIt's unnecessary to use a ``dict`` around a dict literal or dict comprehension, since either syntax already constructs a dict.\nFor example:\n\n* Rewrite ``dict({})`` as ``{}``\n* Rewrite ``dict({\"a\": 1})`` as ``{\"a\": 1}``\n\nC419 Unnecessary list comprehension in ````\\() prevents short-circuiting - rewrite as a generator.\n-----------------------------------------------------------------------------------------------------------\n\nUsing a list comprehension inside a call to ``any()``/``all()`` prevents short-circuiting when a ``True`` / ``False`` value is found.\nThe whole list will be constructed before calling ``any()``/``all()``, potentially wasting work.part-way.\nRewrite to use a generator expression, which can stop part way.\nFor example:\n\n* Rewrite ``all([condition(x) for x in iterable])`` as ``all(condition(x) for x in iterable)``\n* Rewrite ``any([condition(x) for x in iterable])`` as ``any(condition(x) for x in iterable)``\n\nC420: Unnecessary dict comprehension - rewrite using dict.fromkeys().\n----------------------------------------------------------------------\n\nIt's unnecessary to use a dict comprehension to build a dict with all values set to the same constant.\nUse ``dict.fromkeys()`` instead, which is faster.\nFor example:\n\n* Rewrite ``{x: 1 for x in iterable}`` as ``dict.fromkeys(iterable, 1)``\n* Rewrite ``{x: None for x in iterable}`` as ``dict.fromkeys(iterable)``\n","description_content_type":"text/x-rst","docs_url":null,"download_url":null,"downloads":{"last_day":-1,"last_month":-1,"last_week":-1},"dynamic":null,"home_page":null,"keywords":"comprehensions, dict comprehension, flake8, list comprehension, set comprehension","license":null,"license_expression":null,"license_files":null,"maintainer":null,"maintainer_email":null,"name":"flake8-comprehensions","package_url":"https://pypi.org/project/flake8-comprehensions/","platform":null,"project_url":"https://pypi.org/project/flake8-comprehensions/","project_urls":{"Changelog":"https://github.com/adamchainz/flake8-comprehensions/blob/main/CHANGELOG.rst","Funding":"https://adamj.eu/books/","Repository":"https://github.com/adamchainz/flake8-comprehensions"},"provides_extra":null,"release_url":"https://pypi.org/project/flake8-comprehensions/3.16.0/","requires_dist":["flake8!=3.2,>=3"],"requires_python":">=3.9","summary":"A flake8 plugin to help you write better list/set/dict comprehensions.","version":"3.16.0","yanked":false,"yanked_reason":null}

Package search

flake8-comprehensions

project_urls

Dependencies

All package metadata

Releases