=====================
flake8-comprehensions
=====================
.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/flake8-comprehensions/main.yml?branch=main&style=for-the-badge
:target: https://github.com/adamchainz/flake8-comprehensions/actions?workflow=CI
.. image:: https://img.shields.io/pypi/v/flake8-comprehensions.svg?style=for-the-badge
:target: https://pypi.org/project/flake8-comprehensions/
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge
:target: https://github.com/psf/black
.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge
:target: https://github.com/pre-commit/pre-commit
:alt: pre-commit
A `flake8 <https://flake8.readthedocs.io/en/latest/index.html>`_ plugin that helps you write better list/set/dict comprehensions.
Requirements
============
Python 3.8 to 3.12 supported.
Installation
============
First, install with ``pip``:
.. code-block:: sh
python -m pip install flake8-comprehensions
Second, if you define Flake8’s ``select`` setting, add the ``C4`` prefix to it.
Otherwise, the plugin should be active by default.
----
**Linting a Django project?**
Check out my book `Boost Your Django DX <https://adamchainz.gumroad.com/l/byddx>`__ which covers Flake8 and many other code quality tools.
----
Rules
=====
C400-402: Unnecessary generator - rewrite as a ``<list/set/dict>`` comprehension.
---------------------------------------------------------------------------------
Rules:
* C400 Unnecessary generator - rewrite as a list comprehension.
* C401 Unnecessary generator - rewrite as a set comprehension.
* C402 Unnecessary generator - rewrite as a dict comprehension.
It's unnecessary to use ``list``, ``set``, or ``dict`` around a generator expression, since there are equivalent comprehensions for these types.
For example:
* Rewrite ``list(f(x) for x in foo)`` as ``[f(x) for x in foo]``
* Rewrite ``set(f(x) for x in foo)`` as ``{f(x) for x in foo}``
* Rewrite ``dict((x, f(x)) for x in foo)`` as ``{x: f(x) for x in foo}``
C403-404: Unnecessary list comprehension - rewrite as a ``<set/dict>`` comprehension.
-------------------------------------------------------------------------------------
Rules:
* C403 Unnecessary list comprehension - rewrite as a set comprehension.
* C404 Unnecessary list comprehension - rewrite as a dict 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:
* Rewrite ``set([f(x) for x in foo])`` as ``{f(x) for x in foo}``
* Rewrite ``dict([(x, f(x)) for x in foo])`` as ``{x: f(x) for x in foo}``
C405-406: Unnecessary ``<list/tuple>`` literal - rewrite as a ``<set/dict>`` literal.
-------------------------------------------------------------------------------------
* C405 Unnecessary ``<list/tuple>`` literal - rewrite as a set literal.
* C406 Unnecessary ``<list/tuple>`` literal - rewrite as a dict literal.
It's unnecessary to use a list or tuple literal within a call to ``set`` or ``dict``.
For example:
* Rewrite ``set([1, 2])`` as ``{1, 2}``
* Rewrite ``set((1, 2))`` as ``{1, 2}``
* Rewrite ``set([])`` as ``set()``
* Rewrite ``dict([(1, 2)])`` as ``{1: 2}``
* Rewrite ``dict(((1, 2),))`` as ``{1: 2}``
* Rewrite ``dict([])`` as ``{}``
C407: Unnecessary ``<dict/list>`` comprehension - ``<builtin>`` can take a generator
------------------------------------------------------------------------------------
This rule was dropped in version 3.4.0, because it promoted an increase in laziness which could lead to bugs.
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:
* Rewrite ``dict()`` as ``{}``
* Rewrite ``dict(a=1, b=2)`` as ``{"a": 1, "b": 2}``
* Rewrite ``list()`` as ``[]``
* Rewrite ``tuple()`` as ``()``
C409-410: Unnecessary ``<list/tuple>`` passed to ``<list/tuple>``\() - ``<advice>``.
------------------------------------------------------------------------------------
Rules:
* C409 Unnecessary ``<list/tuple>`` passed to tuple() - ``<advice>``.
* C410 Unnecessary list passed to list() - ``<advice>``.
Where ``<advice>`` is either:
* remove the outer call to ``<list/tuple>``\()
* rewrite as a ``<list/tuple>`` literal
It's unnecessary to use a list or tuple literal within a call to ``list`` or ``tuple``, since there is literal syntax for these types.
For example:
* Rewrite ``tuple([1, 2])`` as ``(1, 2)``
* Rewrite ``tuple((1, 2))`` as ``(1, 2)``
* Rewrite ``tuple([])`` as ``()``
* Rewrite ``list([1, 2])`` as ``[1, 2]``
* Rewrite ``list((1, 2))`` as ``[1, 2]``
* Rewrite ``list([])`` as ``[]``
C411: Unnecessary list call - remove the outer call to list().
--------------------------------------------------------------
It's unnecessary to use a ``list`` around a list comprehension, since it is equivalent without it.
For example:
* Rewrite ``list([f(x) for x in foo])`` as ``[f(x) for x in foo]``
C412: Unnecessary ``<dict/list/set>`` comprehension - 'in' can take a generator.
--------------------------------------------------------------------------------
This rule was dropped in version 3.4.0, because it promoted an increase in laziness which could lead to bugs.
C413: Unnecessary ``<list/reversed>`` call around sorted().
-----------------------------------------------------------
It's unnecessary to use ``list()`` around ``sorted()`` as it already returns a list.
It is also unnecessary to use ``reversed()`` around ``sorted()`` as the latter has a ``reverse`` argument.
For example:
* Rewrite ``list(sorted([2, 3, 1]))`` as ``sorted([2, 3, 1])``
* Rewrite ``reversed(sorted([2, 3, 1]))`` as ``sorted([2, 3, 1], reverse=True)``
* Rewrite ``reversed(sorted([2, 3, 1], reverse=True))`` as ``sorted([2, 3, 1])``
C414: Unnecessary ``<list/reversed/set/sorted/tuple>`` call within ``<list/set/sorted/tuple>``\().
--------------------------------------------------------------------------------------------------
It's unnecessary to double-cast or double-process iterables by wrapping the listed functions within ``list``/``set``/``sorted``/``tuple``.
For example:
* Rewrite ``list(list(iterable))`` as ``list(iterable)``
* Rewrite ``list(tuple(iterable))`` as ``list(iterable)``
* Rewrite ``tuple(list(iterable))`` as ``tuple(iterable)``
* Rewrite ``tuple(tuple(iterable))`` as ``tuple(iterable)``
* Rewrite ``set(set(iterable))`` as ``set(iterable)``
* Rewrite ``set(list(iterable))`` as ``set(iterable)``
* Rewrite ``set(tuple(iterable))`` as ``set(iterable)``
* Rewrite ``set(sorted(iterable))`` as ``set(iterable)``
* Rewrite ``set(reversed(iterable))`` as ``set(iterable)``
* Rewrite ``sorted(list(iterable))`` as ``sorted(iterable)``
* Rewrite ``sorted(tuple(iterable))`` as ``sorted(iterable)``
* Rewrite ``sorted(sorted(iterable))`` as ``sorted(iterable)``
* Rewrite ``sorted(reversed(iterable))`` as ``sorted(iterable)``
C415: Unnecessary subscript reversal of iterable within ``<reversed/set/sorted>``\().
-------------------------------------------------------------------------------------
It's unnecessary to reverse the order of an iterable when passing it into one of the listed functions will change the order again.
For example:
* Rewrite ``set(iterable[::-1])`` as ``set(iterable)``
* Rewrite ``sorted(iterable)[::-1]`` as ``sorted(iterable, reverse=True)``
* Rewrite ``reversed(iterable[::-1])`` as ``iterable``
C416: Unnecessary ``<dict/list/set>`` comprehension - rewrite using ``<dict/list/set>``\().
-------------------------------------------------------------------------------------------
It's unnecessary to use a dict/list/set comprehension to build a data structure if the elements are unchanged.
Wrap the iterable with ``dict()``, ``list()``, or ``set()`` instead.
For example:
* Rewrite ``{a: b for a, b in iterable}`` as ``dict(iterable)``
* Rewrite ``[x for x in iterable]`` as ``list(iterable)``
* Rewrite ``{x for x in iterable}`` as ``set(iterable)``
C417: Unnecessary ``map`` usage - rewrite using a generator expression/``<list/set/dict>`` comprehension.
---------------------------------------------------------------------------------------------------------
``map(func, iterable)`` has great performance when ``func`` is a built-in function, and it makes sense if your function already has a name.
But if your func is a ``lambda``, it’s faster to use a generator expression or a comprehension, as it avoids the function call overhead.
For example:
* Rewrite ``map(lambda x: x + 1, iterable)`` to ``(x + 1 for x in iterable)``
* Rewrite ``map(lambda item: get_id(item), items)`` to ``(get_id(item) for item in items)``
* Rewrite ``list(map(lambda num: num * 2, nums))`` to ``[num * 2 for num in nums]``
* Rewrite ``set(map(lambda num: num % 2 == 0, nums))`` to ``{num % 2 == 0 for num in nums}``
* Rewrite ``dict(map(lambda v: (v, v ** 2), values))`` to ``{v : v ** 2 for v in values}``
C418: Unnecessary ``<dict/dict comprehension>`` passed to dict() - remove the outer call to dict()
--------------------------------------------------------------------------------------------------
It's unnecessary to use a ``dict`` around a dict literal or dict comprehension, since either syntax already constructs a dict.
For example:
* Rewrite ``dict({})`` as ``{}``
* Rewrite ``dict({"a": 1})`` as ``{"a": 1}``
C419 Unnecessary list comprehension in ``<any/all>``\() prevents short-circuiting - rewrite as a generator.
-----------------------------------------------------------------------------------------------------------
Using a list comprehension inside a call to ``any()``/``all()`` prevents short-circuiting when a ``True`` / ``False`` value is found.
The whole list will be constructed before calling ``any()``/``all()``, potentially wasting work.part-way.
Rewrite to use a generator expression, which can stop part way.
For example:
* Rewrite ``all([condition(x) for x in iterable])`` as ``all(condition(x) for x in iterable)``
* Rewrite ``any([condition(x) for x in iterable])`` as ``any(condition(x) for x in iterable)``
Raw data
{
"_id": null,
"home_page": "https://github.com/adamchainz/flake8-comprehensions",
"name": "flake8-comprehensions",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": "",
"keywords": "flake8,comprehensions,list comprehension,set comprehension,dict comprehension",
"author": "Adam Johnson",
"author_email": "me@adamj.eu",
"download_url": "https://files.pythonhosted.org/packages/d6/4e/e3324cee771c0604f0b8b82c7cfc29b41e8396c5a4a891f720a6604ec5b0/flake8_comprehensions-3.14.0.tar.gz",
"platform": null,
"description": "=====================\nflake8-comprehensions\n=====================\n\n.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/flake8-comprehensions/main.yml?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 <https://flake8.readthedocs.io/en/latest/index.html>`_ plugin that helps you write better list/set/dict comprehensions.\n\nRequirements\n============\n\nPython 3.8 to 3.12 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\u2019s ``select`` setting, add the ``C4`` prefix to it.\nOtherwise, the plugin should be active by default.\n\n----\n\n**Linting a Django project?**\nCheck out my book `Boost Your Django DX <https://adamchainz.gumroad.com/l/byddx>`__ which covers Flake8 and many other code quality tools.\n\n----\n\nRules\n=====\n\nC400-402: Unnecessary generator - rewrite as a ``<list/set/dict>`` 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 ``<set/dict>`` 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 ``<list/tuple>`` literal - rewrite as a ``<set/dict>`` literal.\n-------------------------------------------------------------------------------------\n\n* C405 Unnecessary ``<list/tuple>`` literal - rewrite as a set literal.\n* C406 Unnecessary ``<list/tuple>`` 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 ``<dict/list>`` comprehension - ``<builtin>`` 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 ``<dict/list/tuple>`` 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 ``<list/tuple>`` passed to ``<list/tuple>``\\() - ``<advice>``.\n------------------------------------------------------------------------------------\n\nRules:\n\n* C409 Unnecessary ``<list/tuple>`` passed to tuple() - ``<advice>``.\n* C410 Unnecessary list passed to list() - ``<advice>``.\n\nWhere ``<advice>`` is either:\n\n* remove the outer call to ``<list/tuple>``\\()\n* rewrite as a ``<list/tuple>`` 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 ``<dict/list/set>`` 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 ``<list/reversed>`` 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 ``<list/reversed/set/sorted/tuple>`` call within ``<list/set/sorted/tuple>``\\().\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 ``<reversed/set/sorted>``\\().\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 ``<dict/list/set>`` comprehension - rewrite using ``<dict/list/set>``\\().\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/``<list/set/dict>`` 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\u2019s 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 ``<dict/dict comprehension>`` 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 ``<any/all>``\\() 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",
"bugtrack_url": null,
"license": "MIT",
"summary": "A flake8 plugin to help you write better list/set/dict comprehensions.",
"version": "3.14.0",
"project_urls": {
"Changelog": "https://github.com/adamchainz/flake8-comprehensions/blob/main/CHANGELOG.rst",
"Homepage": "https://github.com/adamchainz/flake8-comprehensions",
"Mastodon": "https://fosstodon.org/@adamchainz",
"Twitter": "https://twitter.com/adamchainz"
},
"split_keywords": [
"flake8",
"comprehensions",
"list comprehension",
"set comprehension",
"dict comprehension"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "472b24fa5fdcdbda36d37b20b705bba7d5439d57949dfbcdc159a7a0cd5f137b",
"md5": "0269950083cadd3e1325f7e5005e0aa1",
"sha256": "7b9d07d94aa88e62099a6d1931ddf16c344d4157deedf90fe0d8ee2846f30e97"
},
"downloads": -1,
"filename": "flake8_comprehensions-3.14.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "0269950083cadd3e1325f7e5005e0aa1",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 8055,
"upload_time": "2023-07-10T12:46:08",
"upload_time_iso_8601": "2023-07-10T12:46:08.326735Z",
"url": "https://files.pythonhosted.org/packages/47/2b/24fa5fdcdbda36d37b20b705bba7d5439d57949dfbcdc159a7a0cd5f137b/flake8_comprehensions-3.14.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d64ee3324cee771c0604f0b8b82c7cfc29b41e8396c5a4a891f720a6604ec5b0",
"md5": "10e1042bd65bd1f4b151779f7f6acf82",
"sha256": "81768c61bfc064e1a06222df08a2580d97de10cb388694becaf987c331c6c0cf"
},
"downloads": -1,
"filename": "flake8_comprehensions-3.14.0.tar.gz",
"has_sig": false,
"md5_digest": "10e1042bd65bd1f4b151779f7f6acf82",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 12913,
"upload_time": "2023-07-10T12:46:09",
"upload_time_iso_8601": "2023-07-10T12:46:09.579541Z",
"url": "https://files.pythonhosted.org/packages/d6/4e/e3324cee771c0604f0b8b82c7cfc29b41e8396c5a4a891f720a6604ec5b0/flake8_comprehensions-3.14.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-07-10 12:46:09",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "adamchainz",
"github_project": "flake8-comprehensions",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"tox": true,
"lcname": "flake8-comprehensions"
}
JSON
