=================================
Flake8 Unittest Assertion Checker
=================================
|PyPI Version| |Python Versions|
``flake8-assertive`` is a `Flake8 <https://flake8.pycqa.org/>`_ extension that
encourages using richer, more specific `unittest`_ assertions beyond just the
typical ``assertEqual(a, b)`` and ``assertTrue(x)`` methods. The suggested
methods perform more precise checks and provide better failure messages than
the generic methods.
+------------------------------------------+-----------------------------------+------+
| Original | Suggestion | Code |
+==========================================+===================================+======+
| ``assertTrue(a == b)`` | ``assertEqual(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a != b)`` | ``assertNotEqual(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a == b)`` | ``assertNotEqual(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a != b)`` | ``assertEqual(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a < b)`` | ``assertLess(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a <= b)`` | ``assertLessEqual(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a > b)`` | ``assertGreater(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a >= b)`` | ``assertGreaterEqual(a, b)`` | A500 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a is b)`` | ``assertIs(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a is not b)`` | ``assertIsNot(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a is b)`` | ``assertNotIs(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a is not b)`` | ``assertIs(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a in b)`` | ``assertIn(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a not in b)`` | ``assertNotIn(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a in b)`` | ``assertNotIn(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(isinstance(a, b))`` | ``assertIsInstance(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(isinstance(a, b))`` | ``assertNotIsInstance(a, b)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertEqual(a, round(b, x))`` | ``assertAlmostEqual(a, b, x)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertAlmostEqual(a, round(b, x))`` | ``assertAlmostEqual(a, b, x)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertNotEqual(a, round(b, x))`` | ``assertNotAlmostEqual(a, b, x)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertNotAlmostEqual(a, round(b, x))`` | ``assertNotAlmostEqual(a, b, x)`` | A501 |
+------------------------------------------+-----------------------------------+------+
| ``assertEqual(a, None)`` | ``assertIsNone(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertNotEqual(a, None)`` | ``assertIsNotNone(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a is None)`` | ``assertIsNone(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a is not None)`` | ``assertIsNotNone(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a is None)`` | ``assertIsNotNone(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a is not None)`` | ``assertIsNone(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertEqual(a, True)`` | ``assertTrue(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertEqual(a, False)`` | ``assertFalse(a)`` | A502 |
+------------------------------------------+-----------------------------------+------+
| ``assertEquals(a, b)`` | ``assertEqual(a, b)`` | A503 |
+------------------------------------------+-----------------------------------+------+
| ``assertNotEquals(a, b)`` | ``assertNotEqual(a, b)`` | A503 |
+------------------------------------------+-----------------------------------+------+
| ``assertAlmostEquals(a, b, x)`` | ``assertAlmostEqual(a, b, x)`` | A503 |
+------------------------------------------+-----------------------------------+------+
| ``assertNotAlmostEquals(a, b, x)`` | ``assertNotAlmostEqual(a, b, x)`` | A503 |
+------------------------------------------+-----------------------------------+------+
| ``assertTrue(a, b)`` | ``assertTrue(a, msg=b)`` | A504 |
+------------------------------------------+-----------------------------------+------+
| ``assertFalse(a, b)`` | ``assertFalse(a, msg=b)`` | A504 |
+------------------------------------------+-----------------------------------+------+
Note that some suggestions are normalized forms of the original, such as when
a double-negative is used (``assertFalse(a != b)`` → ``assertEqual(a, b)``).
There aren't suggestions for things like ``assertFalse(a > b)``, which may or
may not be equivalent to ``assertLessEqual(a, b)``.
Installation
------------
Install from PyPI using ``pip``:
.. code-block:: sh
$ pip install flake8-assertive
The extension will be activated automatically by ``flake8``. You can verify
that it has been loaded by inspecting the ``flake8 --version`` string.
.. code-block:: sh
$ flake8 --version
4.0.1 (assertive: 2.1.0, ...) CPython 3.9.10 on Darwin
Error Codes
-----------
This extension adds three new `error codes`__ (using the ``A50`` prefix):
- ``A500``: prefer *{func}* for '*{op}*' comparisons
- ``A501``: prefer *{func}* for '*{op}*' expressions
- ``A502``: prefer *{func}* instead of comparing to *{obj}*
- ``A503``: use *{func}* instead of the deprecated *{name}*
- ``A504``: prefer the 'msg=' kwarg for *{func}* diagnostics
.. __: https://flake8.pycqa.org/en/latest/user/error-codes.html
Configuration
-------------
Configuration values are specified in the ``[flake8]`` section of your `config
file`_ or as command line arguments (e.g. ``--assertive-snakecase``).
- ``assertive-snakecase``: suggest snake_case assert method names
(e.g. ``assert_true()``) instead of the standard names (e.g. ``assertTrue()``)
- ``assertive-test-pattern``: `fnmatch`_ pattern for identifying unittest test
files (and all other files will be skipped)
.. _fnmatch: https://docs.python.org/library/fnmatch.html
.. _unittest: https://docs.python.org/library/unittest.html
.. _config file: https://flake8.pycqa.org/en/latest/user/configuration.html
Caveats
-------
There are some specific cases when the suggestion might not match the intent
of the original.
Testing the equality operator
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
``assertEqual()`` won't use the ``==`` operator if the comparison has been
delegated to a `type-specific equalilty function`__. By default, this is the
case for strings, sequences, lists, tuples, sets, and dicts.
.. __: https://docs.python.org/3/library/unittest.html#unittest.TestCase.addTypeEqualityFunc
If your intent is to specifically test the ``==`` operator, consider writing
the assertion like this instead:
.. code-block:: python
assertIs(a == b, True)
This approach has the benefit of verifying that the type's ``__eq__``
implementation returns a boolean value. Unfortunately, it also has the
downside of reporting the result of ``a == b`` on failure instead of the
values of ``a`` and ``b``.
Suggested by: `Serhiy Storchaka <https://twitter.com/SerhiyStorchaka>`_
Alternatives
------------
- `Teyit <https://github.com/isidentical/teyit>`_ is a Python unit test formatter that
can perform similar assertion transformations.
.. |PyPI Version| image:: https://img.shields.io/pypi/v/flake8-assertive.svg
:target: https://pypi.python.org/pypi/flake8-assertive
.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/flake8-assertive.svg
:target: https://pypi.python.org/pypi/flake8-assertive
=======
Changes
=======
2.2.0 (2025-10-11)
------------------
* Drop support for Python 3.7, 3.8, and 3.9. Python 3.10+ is now required.
2.1.0 (2022-03-15)
------------------
* Suggest using an explicit `msg` keyword argument with ``assertTrue()`` and
``assertFalse()`` to avoid accidental two-argument misuse. This is controlled
by a new error code: ``A504``
2.0.0 (2021-12-30)
------------------
* Drop support for Python 2.7 and 3.6, and add 3.10.
* Drop support for flake8 2.x versions.
1.3.0 (2020-10-12)
------------------
* Drop Python version 3.5 support and add version 3.9.
1.2.1 (2019-12-08)
------------------
* Support keyword arguments in assert method calls.
1.2.0 (2019-12-05)
------------------
* Suggest the preferred names for deprecated methods, such as
``assertEqual()`` instead of ``assertEquals()``.
1.1.0 (2019-06-26)
------------------
* Suggest ``assertAlmostEqual(a, b, x)`` for ``round()`` expressions like in
``assertEqual(a, round(b, x))`` and ``assertAlmostEqual(a, round(b, x))``
(and similar for ``assertNotEqual()`` and ``assertNotAlmostEqual()``.
* Recognize ``assertAmostEquals()`` and ``assertNotAlmostEquals()`` as aliases
for ``assertAlmostEqual()`` and ``assertNotAlmostEqual()``.
* Drop Python 3.4 as a supported version since it has been officially retired.
1.0.1 (2018-07-03)
------------------
* Don't make suggestions for assertions containing multiple comparison
operations (e.g. ``assertTrue(a == b == c)``).
1.0.0 (2018-06-04)
------------------
* Suggest ``assertIsNone(a)`` for ``assertTrue(a is None)``, etc.
* Recognize ``assertEquals()`` and ``assertNotEquals()`` as aliases for
``assertEqual()`` and ``assertNotEqual()``.
0.9.0 (2018-05-14)
------------------
* Initial beta release
Raw data
{
"_id": null,
"home_page": "https://github.com/jparise/flake8-assertive",
"name": "flake8-assertive",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "flake8 testing unittest assert",
"author": "Jon Parise",
"author_email": "jon@indelible.org",
"download_url": "https://files.pythonhosted.org/packages/14/93/260721c99e14a92542b0340247db008d7c09c42751a47152a1d598a4517d/flake8_assertive-2.2.0.tar.gz",
"platform": null,
"description": "=================================\nFlake8 Unittest Assertion Checker\n=================================\n\n|PyPI Version| |Python Versions|\n\n``flake8-assertive`` is a `Flake8 <https://flake8.pycqa.org/>`_ extension that\nencourages using richer, more specific `unittest`_ assertions beyond just the\ntypical ``assertEqual(a, b)`` and ``assertTrue(x)`` methods. The suggested\nmethods perform more precise checks and provide better failure messages than\nthe generic methods.\n\n+------------------------------------------+-----------------------------------+------+\n| Original | Suggestion | Code |\n+==========================================+===================================+======+\n| ``assertTrue(a == b)`` | ``assertEqual(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a != b)`` | ``assertNotEqual(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a == b)`` | ``assertNotEqual(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a != b)`` | ``assertEqual(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a < b)`` | ``assertLess(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a <= b)`` | ``assertLessEqual(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a > b)`` | ``assertGreater(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a >= b)`` | ``assertGreaterEqual(a, b)`` | A500 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a is b)`` | ``assertIs(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a is not b)`` | ``assertIsNot(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a is b)`` | ``assertNotIs(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a is not b)`` | ``assertIs(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a in b)`` | ``assertIn(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a not in b)`` | ``assertNotIn(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a in b)`` | ``assertNotIn(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(isinstance(a, b))`` | ``assertIsInstance(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(isinstance(a, b))`` | ``assertNotIsInstance(a, b)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertEqual(a, round(b, x))`` | ``assertAlmostEqual(a, b, x)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertAlmostEqual(a, round(b, x))`` | ``assertAlmostEqual(a, b, x)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertNotEqual(a, round(b, x))`` | ``assertNotAlmostEqual(a, b, x)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertNotAlmostEqual(a, round(b, x))`` | ``assertNotAlmostEqual(a, b, x)`` | A501 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertEqual(a, None)`` | ``assertIsNone(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertNotEqual(a, None)`` | ``assertIsNotNone(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a is None)`` | ``assertIsNone(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a is not None)`` | ``assertIsNotNone(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a is None)`` | ``assertIsNotNone(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a is not None)`` | ``assertIsNone(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertEqual(a, True)`` | ``assertTrue(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertEqual(a, False)`` | ``assertFalse(a)`` | A502 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertEquals(a, b)`` | ``assertEqual(a, b)`` | A503 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertNotEquals(a, b)`` | ``assertNotEqual(a, b)`` | A503 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertAlmostEquals(a, b, x)`` | ``assertAlmostEqual(a, b, x)`` | A503 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertNotAlmostEquals(a, b, x)`` | ``assertNotAlmostEqual(a, b, x)`` | A503 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertTrue(a, b)`` | ``assertTrue(a, msg=b)`` | A504 |\n+------------------------------------------+-----------------------------------+------+\n| ``assertFalse(a, b)`` | ``assertFalse(a, msg=b)`` | A504 |\n+------------------------------------------+-----------------------------------+------+\n\nNote that some suggestions are normalized forms of the original, such as when\na double-negative is used (``assertFalse(a != b)`` \u2192 ``assertEqual(a, b)``).\nThere aren't suggestions for things like ``assertFalse(a > b)``, which may or\nmay not be equivalent to ``assertLessEqual(a, b)``.\n\n\nInstallation\n------------\n\nInstall from PyPI using ``pip``:\n\n.. code-block:: sh\n\n $ pip install flake8-assertive\n\nThe extension will be activated automatically by ``flake8``. You can verify\nthat it has been loaded by inspecting the ``flake8 --version`` string.\n\n.. code-block:: sh\n\n $ flake8 --version\n 4.0.1 (assertive: 2.1.0, ...) CPython 3.9.10 on Darwin\n\n\nError Codes\n-----------\n\nThis extension adds three new `error codes`__ (using the ``A50`` prefix):\n\n- ``A500``: prefer *{func}* for '*{op}*' comparisons\n- ``A501``: prefer *{func}* for '*{op}*' expressions\n- ``A502``: prefer *{func}* instead of comparing to *{obj}*\n- ``A503``: use *{func}* instead of the deprecated *{name}*\n- ``A504``: prefer the 'msg=' kwarg for *{func}* diagnostics\n\n.. __: https://flake8.pycqa.org/en/latest/user/error-codes.html\n\nConfiguration\n-------------\n\nConfiguration values are specified in the ``[flake8]`` section of your `config\nfile`_ or as command line arguments (e.g. ``--assertive-snakecase``).\n\n- ``assertive-snakecase``: suggest snake_case assert method names\n (e.g. ``assert_true()``) instead of the standard names (e.g. ``assertTrue()``)\n- ``assertive-test-pattern``: `fnmatch`_ pattern for identifying unittest test\n files (and all other files will be skipped)\n\n.. _fnmatch: https://docs.python.org/library/fnmatch.html\n.. _unittest: https://docs.python.org/library/unittest.html\n.. _config file: https://flake8.pycqa.org/en/latest/user/configuration.html\n\nCaveats\n-------\n\nThere are some specific cases when the suggestion might not match the intent\nof the original.\n\nTesting the equality operator\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n``assertEqual()`` won't use the ``==`` operator if the comparison has been\ndelegated to a `type-specific equalilty function`__. By default, this is the\ncase for strings, sequences, lists, tuples, sets, and dicts.\n\n.. __: https://docs.python.org/3/library/unittest.html#unittest.TestCase.addTypeEqualityFunc\n\nIf your intent is to specifically test the ``==`` operator, consider writing\nthe assertion like this instead:\n\n.. code-block:: python\n\n assertIs(a == b, True)\n\nThis approach has the benefit of verifying that the type's ``__eq__``\nimplementation returns a boolean value. Unfortunately, it also has the\ndownside of reporting the result of ``a == b`` on failure instead of the\nvalues of ``a`` and ``b``.\n\nSuggested by: `Serhiy Storchaka <https://twitter.com/SerhiyStorchaka>`_\n\nAlternatives\n------------\n\n- `Teyit <https://github.com/isidentical/teyit>`_ is a Python unit test formatter that\n can perform similar assertion transformations.\n\n.. |PyPI Version| image:: https://img.shields.io/pypi/v/flake8-assertive.svg\n :target: https://pypi.python.org/pypi/flake8-assertive\n.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/flake8-assertive.svg\n :target: https://pypi.python.org/pypi/flake8-assertive\n\n=======\nChanges\n=======\n\n2.2.0 (2025-10-11)\n------------------\n\n* Drop support for Python 3.7, 3.8, and 3.9. Python 3.10+ is now required.\n\n2.1.0 (2022-03-15)\n------------------\n\n* Suggest using an explicit `msg` keyword argument with ``assertTrue()`` and\n ``assertFalse()`` to avoid accidental two-argument misuse. This is controlled\n by a new error code: ``A504``\n\n2.0.0 (2021-12-30)\n------------------\n\n* Drop support for Python 2.7 and 3.6, and add 3.10.\n* Drop support for flake8 2.x versions.\n\n1.3.0 (2020-10-12)\n------------------\n\n* Drop Python version 3.5 support and add version 3.9.\n\n1.2.1 (2019-12-08)\n------------------\n\n* Support keyword arguments in assert method calls.\n\n1.2.0 (2019-12-05)\n------------------\n\n* Suggest the preferred names for deprecated methods, such as\n ``assertEqual()`` instead of ``assertEquals()``.\n\n1.1.0 (2019-06-26)\n------------------\n\n* Suggest ``assertAlmostEqual(a, b, x)`` for ``round()`` expressions like in\n ``assertEqual(a, round(b, x))`` and ``assertAlmostEqual(a, round(b, x))``\n (and similar for ``assertNotEqual()`` and ``assertNotAlmostEqual()``.\n* Recognize ``assertAmostEquals()`` and ``assertNotAlmostEquals()`` as aliases\n for ``assertAlmostEqual()`` and ``assertNotAlmostEqual()``.\n* Drop Python 3.4 as a supported version since it has been officially retired.\n\n1.0.1 (2018-07-03)\n------------------\n\n* Don't make suggestions for assertions containing multiple comparison\n operations (e.g. ``assertTrue(a == b == c)``).\n\n1.0.0 (2018-06-04)\n------------------\n\n* Suggest ``assertIsNone(a)`` for ``assertTrue(a is None)``, etc.\n* Recognize ``assertEquals()`` and ``assertNotEquals()`` as aliases for\n ``assertEqual()`` and ``assertNotEqual()``.\n\n0.9.0 (2018-05-14)\n------------------\n\n* Initial beta release\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Flake8 unittest assert method checker",
"version": "2.2.0",
"project_urls": {
"Homepage": "https://github.com/jparise/flake8-assertive",
"Issue Tracker": "https://github.com/jparise/flake8-assertive/issues",
"Source Code": "https://github.com/jparise/flake8-assertive"
},
"split_keywords": [
"flake8",
"testing",
"unittest",
"assert"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "9f123dc01f66d3df80a35b1876d37b0fb307b6dab3e2eb4a870ea8356a3f341f",
"md5": "4e60dd7d38ddaff9ed9ea1126304d720",
"sha256": "4c993d0fcec04fbaea50a8ee8b96cc11cab06bbe52fd044c07010424f257a4da"
},
"downloads": -1,
"filename": "flake8_assertive-2.2.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "4e60dd7d38ddaff9ed9ea1126304d720",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 7899,
"upload_time": "2025-10-11T20:33:26",
"upload_time_iso_8601": "2025-10-11T20:33:26.421912Z",
"url": "https://files.pythonhosted.org/packages/9f/12/3dc01f66d3df80a35b1876d37b0fb307b6dab3e2eb4a870ea8356a3f341f/flake8_assertive-2.2.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "1493260721c99e14a92542b0340247db008d7c09c42751a47152a1d598a4517d",
"md5": "fc9b0eb52871f5275ac23efa995107e3",
"sha256": "cf87346d15eb8f969ea44a5e31503899405158758116fd965ecff61b7f9b4749"
},
"downloads": -1,
"filename": "flake8_assertive-2.2.0.tar.gz",
"has_sig": false,
"md5_digest": "fc9b0eb52871f5275ac23efa995107e3",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 9051,
"upload_time": "2025-10-11T20:33:27",
"upload_time_iso_8601": "2025-10-11T20:33:27.555238Z",
"url": "https://files.pythonhosted.org/packages/14/93/260721c99e14a92542b0340247db008d7c09c42751a47152a1d598a4517d/flake8_assertive-2.2.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-10-11 20:33:27",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "jparise",
"github_project": "flake8-assertive",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "black",
"specs": [
[
"==",
"25.9.0"
]
]
},
{
"name": "flake8",
"specs": [
[
"==",
"7.3.0"
]
]
},
{
"name": "pytest",
"specs": [
[
"==",
"8.4.0"
]
]
}
],
"lcname": "flake8-assertive"
}
JSON
