flake8-builtins 2.2.0__tar.gz → 2.3.0__tar.gz

{flake8_builtins-2.2.0 → flake8_builtins-2.3.0}/CHANGES.rst

@@ -3,6 +3,13 @@
 Changelog
 =========
 
+2.3.0 (2024-03-29)
+------------------
+
+- Add rule for builtin module name shadowing (`A005`).
+  [asfaltboy]
+
+
 2.2.0 (2023-11-03)
 ------------------
 

flake8_builtins-2.3.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.1
+Name: flake8-builtins
+Version: 2.3.0
+Summary: Check for python builtins being used as variables or parameters
+Project-URL: Homepage, https://github.com/gforcada/flake8-builtins
+Project-URL: Bug Tracker, https://github.com/gforcada/flake8-builtins/issues
+Project-URL: Changelog, https://github.com/gforcada/flake8-builtins/blob/main/CHANGES.rst
+Author-email: Gil Forcada Codinachs <gil.gnome@gmail.com>
+License-File: LICENSE
+Keywords: flake8,pep8,python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Framework :: Flake8
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Requires-Dist: flake8
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/x-rst
+
+.. -*- coding: utf-8 -*-
+
+.. image:: https://github.com/gforcada/flake8-builtins/actions/workflows/testing.yml/badge.svg?branch=main
+   :target: https://github.com/gforcada/flake8-builtins/actions/workflows/testing.yml
+
+.. image:: https://coveralls.io/repos/gforcada/flake8-builtins/badge.svg?branch=main
+   :target: https://coveralls.io/github/gforcada/flake8-builtins?branch=main
+
+Flake8 Builtins plugin
+======================
+Check for python builtins being used as variables or parameters.
+
+Imagine some code like this:
+
+.. code:: Python
+
+    def max_values(list, list2):
+        max = list[0]
+        for x in list:
+            if x > 0:
+                max = x
+
+        all_values = list()
+        all_values.append(max)
+
+        max = list2[0]
+        for x in list2:
+            if x > 0:
+                max = x
+        all_values.append(max)
+
+        return all_values
+
+    max_values([3, 4, 5, ], [5, 6, 7])
+
+The last statement is not returning ``[5, 7]`` as one would expect,
+instead is raising this exception::
+
+    Traceback (most recent call last):
+      File "test.py", line 17, in <module>
+        max_values([3,4,5], [4,5,6])
+      File "bla.py", line 6, in max_values
+        all_values = list()
+    TypeError: 'list' object is not callable
+
+**Why?** Because ``max_value`` function's first argument is ``list`` a Python builtin.
+Python allows to override them, but although could be useful in some really specific use cases,
+the general approach is to **not** do that as code then can suddenly break without a clear trace.
+
+Example
+-------
+Given the following code:
+
+.. code:: Python
+
+    def my_method(object, list, dict):
+        max = 5
+        min = 3
+        zip = (4, 3)
+
+The following warnings are shown (via flake8)::
+
+   test.py:1:15: A002 argument "object" is shadowing a python builtin
+   test.py:1:23: A002 argument "list" is shadowing a python builtin
+   test.py:1:29: A002 argument "dict" is shadowing a python builtin
+   test.py:2:5: A001 variable "max" is shadowing a python builtin
+   test.py:3:5: A001 variable "min" is shadowing a python builtin
+   test.py:4:5: A001 variable "zip" is shadowing a python builtin
+
+Install
+-------
+Install with pip::
+
+    $ python -m pip install flake8-builtins
+
+Options
+-------
+
+One can use `--builtins-ignorelist` option, or configuration option,
+to ignore a custom list of builtins::
+
+    $ flake8 --builtins-ignorelist id,copyright *.py
+
+Requirements
+------------
+- Python 3.8, 3.9, 3.10, 3.11, 3.12, and pypy3
+- flake8
+
+Rules
+-----
+
+A001:
+  A variable is shadowing a Python builtin.
+
+A002:
+  An argument is shadowing a Python builtin.
+
+A003:
+  A class attribute is shadowing a Python builtin.
+
+A004:
+  An import statement is shadowing a Python builtin.
+
+A005:
+  A module is shadowing a Python builtin module (e.g: `logging` or `socket`)
+
+License
+-------
+GPL 2.0

{flake8_builtins-2.2.0 → flake8_builtins-2.3.0}/README.rst

@@ -83,7 +83,7 @@ to ignore a custom list of builtins::
 
 Requirements
 ------------
-- Python 3.8, 3.9, 3.10, 3.11, and pypy3
+- Python 3.8, 3.9, 3.10, 3.11, 3.12, and pypy3
 - flake8
 
 Rules
@@ -101,6 +101,9 @@ A003:
 A004:
   An import statement is shadowing a Python builtin.
 
+A005:
+  A module is shadowing a Python builtin module (e.g: `logging` or `socket`)
+
 License
 -------
 GPL 2.0

{flake8_builtins-2.2.0 → flake8_builtins-2.3.0}/flake8_builtins.py

@@ -1,8 +1,10 @@
 from flake8 import utils as stdin_utils
+from pathlib import Path
 
 import ast
 import builtins
 import inspect
+import sys
 
 
 class BuiltinsChecker:
@@ -12,6 +14,7 @@ class BuiltinsChecker:
     argument_msg = 'A002 argument "{0}" is shadowing a Python builtin'
     class_attribute_msg = 'A003 class attribute "{0}" is shadowing a Python builtin'
     import_msg = 'A004 import statement "{0}" is shadowing a Python builtin'
+    module_name_msg = 'A005 the module is shadowing a Python builtin module "{0}"'
 
     names = []
     ignore_list = {
@@ -20,6 +23,7 @@ class BuiltinsChecker:
         'credits',
         '_',
     }
+    ignored_module_names = set()
 
     def __init__(self, tree, filename):
         self.tree = tree
@@ -34,6 +38,13 @@ class BuiltinsChecker:
             comma_separated_list=True,
             help='A comma separated list of builtins to skip checking',
         )
+        option_manager.add_option(
+            '--builtins-allowed-modules',
+            metavar='builtins',
+            parse_from_config=True,
+            comma_separated_list=True,
+            help='A comma separated list of builtin module names to allow',
+        )
 
     @classmethod
     def parse_options(cls, options):
@@ -47,12 +58,26 @@ class BuiltinsChecker:
         if flake8_builtins:
             cls.names.update(flake8_builtins)
 
+        if options.builtins_allowed_modules is not None:
+            cls.ignored_module_names.update(options.builtins_allowed_modules)
+
+        if hasattr(sys, 'stdlib_module_names'):
+            # stdlib_module_names is only available in Python 3.10+
+            known_module_names = sys.stdlib_module_names
+            cls.module_names = {
+                m for m in known_module_names if m not in cls.ignored_module_names
+            }
+        else:
+            cls.module_names = set()
+
     def run(self):
         tree = self.tree
 
         if self.filename == 'stdin':
             lines = stdin_utils.stdin_get_value()
             tree = ast.parse(lines)
+        else:
+            yield from self.check_module_name(self.filename)
 
         for statement in ast.walk(tree):
             for child in ast.iter_child_nodes(statement):
@@ -234,13 +259,26 @@ class BuiltinsChecker:
         if statement.name in self.names:
             yield self.error(statement, variable=statement.name)
 
-    def error(self, statement, variable, message=None):
+    def error(self, statement=None, variable=None, message=None):
         if not message:
             message = self.assign_msg
 
+        # lineno and col_offset must be integers
         return (
-            statement.lineno,
-            statement.col_offset,
+            statement.lineno if statement else 0,
+            statement.col_offset if statement else 0,
             message.format(variable),
             type(self),
         )
+
+    def check_module_name(self, filename: str):
+        if not self.module_names:
+            return
+        path = Path(filename)
+        module_name = path.name.removesuffix('.py')
+        if module_name in self.module_names:
+            yield self.error(
+                None,
+                module_name,
+                message=self.module_name_msg,
+            )

{flake8_builtins-2.2.0 → flake8_builtins-2.3.0}/pyproject.toml

@@ -4,13 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flake8-builtins"
-version = "2.2.0"
+version = "2.3.0"
 authors = [
   { name="Gil Forcada Codinachs", email="gil.gnome@gmail.com" },
 ]
 description = "Check for python builtins being used as variables or parameters"
 keywords = ["pep8", "flake8", "python", ]
-license = {file = "LICENSE"}
 readme = "README.rst"
 requires-python = ">=3.8"
 classifiers = [

{flake8_builtins-2.2.0 → flake8_builtins-2.3.0}/run_tests.py

@@ -10,15 +10,25 @@ import textwrap
 class FakeOptions:
     builtins_ignorelist = []
     builtins = None
+    builtins_allowed_modules = None
 
-    def __init__(self, ignore_list='', builtins=None):
+    def __init__(self, ignore_list='', builtins=None, builtins_allowed_modules=None):
         if ignore_list:
             self.builtins_ignorelist = ignore_list
         if builtins:
             self.builtins = builtins
-
-
-def check_code(source, expected_codes=None, ignore_list=None, builtins=None):
+        if builtins_allowed_modules:
+            self.builtins_allowed_modules = builtins_allowed_modules
+
+
+def check_code(
+    source,
+    expected_codes=None,
+    ignore_list=None,
+    builtins=None,
+    builtins_allowed_modules=None,
+    filename='/home/script.py',
+):
     """Check if the given source code generates the given flake8 errors
 
     If `expected_codes` is a string is converted to a list,
@@ -37,8 +47,14 @@ def check_code(source, expected_codes=None, ignore_list=None, builtins=None):
     if ignore_list is None:
         ignore_list = []
     tree = ast.parse(textwrap.dedent(source))
-    checker = BuiltinsChecker(tree, '/home/script.py')
-    checker.parse_options(FakeOptions(ignore_list=ignore_list, builtins=builtins))
+    checker = BuiltinsChecker(tree, filename)
+    checker.parse_options(
+        FakeOptions(
+            ignore_list=ignore_list,
+            builtins=builtins,
+            builtins_allowed_modules=builtins_allowed_modules,
+        )
+    )
     return_statements = list(checker.run())
 
     assert len(return_statements) == len(expected_codes)
@@ -463,12 +479,36 @@ def test_async_with_nothing():
 def test_stdin(stdin_get_value):
     source = 'max = 4'
     stdin_get_value.return_value = source
-    checker = BuiltinsChecker('', 'stdin')
-    checker.parse_options(FakeOptions())
-    ret = list(checker.run())
-    assert len(ret) == 1
+    check_code('', expected_codes='A001', filename='stdin')
 
 
 def test_tuple_unpacking():
     source = 'a, *(b, c) = 1, 2, 3'
     check_code(source)
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 10),
+    reason='Skip A005, module testing is only supported in Python 3.10 and above',
+)
+def test_module_name():
+    source = ''
+    check_code(source, expected_codes='A005', filename='./temp/logging.py')
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 10),
+    reason='Skip A005, module testing is only supported in Python 3.10 and above',
+)
+def test_module_name_ignore_module():
+    source = ''
+    check_code(
+        source,
+        filename='./temp/logging.py',
+        builtins_allowed_modules=['logging'],
+    )
+
+
+def test_module_name_not_builtin():
+    source = ''
+    check_code(source, filename='log_config')

{flake8_builtins-2.2.0 → flake8_builtins-2.3.0}/tox.ini

@@ -44,6 +44,7 @@ description = get a test coverage report
 use_develop = true
 skip_install = false
 deps =
+    pytest-cov
     coverage
 commands =
     pytest run_tests.py --cov --cov-report term-missing

flake8_builtins-2.2.0/PKG-INFO

@@ -1,479 +0,0 @@
-Metadata-Version: 2.1
-Name: flake8-builtins
-Version: 2.2.0
-Summary: Check for python builtins being used as variables or parameters
-Project-URL: Homepage, https://github.com/gforcada/flake8-builtins
-Project-URL: Bug Tracker, https://github.com/gforcada/flake8-builtins/issues
-Project-URL: Changelog, https://github.com/gforcada/flake8-builtins/blob/main/CHANGES.rst
-Author-email: Gil Forcada Codinachs <gil.gnome@gmail.com>
-License:                     GNU GENERAL PUBLIC LICENSE
-                               Version 2, June 1991
-        
-         Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
-         51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-         Everyone is permitted to copy and distribute verbatim copies
-         of this license document, but changing it is not allowed.
-        
-                                    Preamble
-        
-          The licenses for most software are designed to take away your
-        freedom to share and change it.  By contrast, the GNU General Public
-        License is intended to guarantee your freedom to share and change free
-        software--to make sure the software is free for all its users.  This
-        General Public License applies to most of the Free Software
-        Foundation's software and to any other program whose authors commit to
-        using it.  (Some other Free Software Foundation software is covered by
-        the GNU Lesser General Public License instead.)  You can apply it to
-        your programs, too.
-        
-          When we speak of free software, we are referring to freedom, not
-        price.  Our General Public Licenses are designed to make sure that you
-        have the freedom to distribute copies of free software (and charge for
-        this service if you wish), that you receive source code or can get it
-        if you want it, that you can change the software or use pieces of it
-        in new free programs; and that you know you can do these things.
-        
-          To protect your rights, we need to make restrictions that forbid
-        anyone to deny you these rights or to ask you to surrender the rights.
-        These restrictions translate to certain responsibilities for you if you
-        distribute copies of the software, or if you modify it.
-        
-          For example, if you distribute copies of such a program, whether
-        gratis or for a fee, you must give the recipients all the rights that
-        you have.  You must make sure that they, too, receive or can get the
-        source code.  And you must show them these terms so they know their
-        rights.
-        
-          We protect your rights with two steps: (1) copyright the software, and
-        (2) offer you this license which gives you legal permission to copy,
-        distribute and/or modify the software.
-        
-          Also, for each author's protection and ours, we want to make certain
-        that everyone understands that there is no warranty for this free
-        software.  If the software is modified by someone else and passed on, we
-        want its recipients to know that what they have is not the original, so
-        that any problems introduced by others will not reflect on the original
-        authors' reputations.
-        
-          Finally, any free program is threatened constantly by software
-        patents.  We wish to avoid the danger that redistributors of a free
-        program will individually obtain patent licenses, in effect making the
-        program proprietary.  To prevent this, we have made it clear that any
-        patent must be licensed for everyone's free use or not licensed at all.
-        
-          The precise terms and conditions for copying, distribution and
-        modification follow.
-        
-                            GNU GENERAL PUBLIC LICENSE
-           TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-        
-          0. This License applies to any program or other work which contains
-        a notice placed by the copyright holder saying it may be distributed
-        under the terms of this General Public License.  The "Program", below,
-        refers to any such program or work, and a "work based on the Program"
-        means either the Program or any derivative work under copyright law:
-        that is to say, a work containing the Program or a portion of it,
-        either verbatim or with modifications and/or translated into another
-        language.  (Hereinafter, translation is included without limitation in
-        the term "modification".)  Each licensee is addressed as "you".
-        
-        Activities other than copying, distribution and modification are not
-        covered by this License; they are outside its scope.  The act of
-        running the Program is not restricted, and the output from the Program
-        is covered only if its contents constitute a work based on the
-        Program (independent of having been made by running the Program).
-        Whether that is true depends on what the Program does.
-        
-          1. You may copy and distribute verbatim copies of the Program's
-        source code as you receive it, in any medium, provided that you
-        conspicuously and appropriately publish on each copy an appropriate
-        copyright notice and disclaimer of warranty; keep intact all the
-        notices that refer to this License and to the absence of any warranty;
-        and give any other recipients of the Program a copy of this License
-        along with the Program.
-        
-        You may charge a fee for the physical act of transferring a copy, and
-        you may at your option offer warranty protection in exchange for a fee.
-        
-          2. You may modify your copy or copies of the Program or any portion
-        of it, thus forming a work based on the Program, and copy and
-        distribute such modifications or work under the terms of Section 1
-        above, provided that you also meet all of these conditions:
-        
-            a) You must cause the modified files to carry prominent notices
-            stating that you changed the files and the date of any change.
-        
-            b) You must cause any work that you distribute or publish, that in
-            whole or in part contains or is derived from the Program or any
-            part thereof, to be licensed as a whole at no charge to all third
-            parties under the terms of this License.
-        
-            c) If the modified program normally reads commands interactively
-            when run, you must cause it, when started running for such
-            interactive use in the most ordinary way, to print or display an
-            announcement including an appropriate copyright notice and a
-            notice that there is no warranty (or else, saying that you provide
-            a warranty) and that users may redistribute the program under
-            these conditions, and telling the user how to view a copy of this
-            License.  (Exception: if the Program itself is interactive but
-            does not normally print such an announcement, your work based on
-            the Program is not required to print an announcement.)
-        
-        These requirements apply to the modified work as a whole.  If
-        identifiable sections of that work are not derived from the Program,
-        and can be reasonably considered independent and separate works in
-        themselves, then this License, and its terms, do not apply to those
-        sections when you distribute them as separate works.  But when you
-        distribute the same sections as part of a whole which is a work based
-        on the Program, the distribution of the whole must be on the terms of
-        this License, whose permissions for other licensees extend to the
-        entire whole, and thus to each and every part regardless of who wrote it.
-        
-        Thus, it is not the intent of this section to claim rights or contest
-        your rights to work written entirely by you; rather, the intent is to
-        exercise the right to control the distribution of derivative or
-        collective works based on the Program.
-        
-        In addition, mere aggregation of another work not based on the Program
-        with the Program (or with a work based on the Program) on a volume of
-        a storage or distribution medium does not bring the other work under
-        the scope of this License.
-        
-          3. You may copy and distribute the Program (or a work based on it,
-        under Section 2) in object code or executable form under the terms of
-        Sections 1 and 2 above provided that you also do one of the following:
-        
-            a) Accompany it with the complete corresponding machine-readable
-            source code, which must be distributed under the terms of Sections
-            1 and 2 above on a medium customarily used for software interchange; or,
-        
-            b) Accompany it with a written offer, valid for at least three
-            years, to give any third party, for a charge no more than your
-            cost of physically performing source distribution, a complete
-            machine-readable copy of the corresponding source code, to be
-            distributed under the terms of Sections 1 and 2 above on a medium
-            customarily used for software interchange; or,
-        
-            c) Accompany it with the information you received as to the offer
-            to distribute corresponding source code.  (This alternative is
-            allowed only for noncommercial distribution and only if you
-            received the program in object code or executable form with such
-            an offer, in accord with Subsection b above.)
-        
-        The source code for a work means the preferred form of the work for
-        making modifications to it.  For an executable work, complete source
-        code means all the source code for all modules it contains, plus any
-        associated interface definition files, plus the scripts used to
-        control compilation and installation of the executable.  However, as a
-        special exception, the source code distributed need not include
-        anything that is normally distributed (in either source or binary
-        form) with the major components (compiler, kernel, and so on) of the
-        operating system on which the executable runs, unless that component
-        itself accompanies the executable.
-        
-        If distribution of executable or object code is made by offering
-        access to copy from a designated place, then offering equivalent
-        access to copy the source code from the same place counts as
-        distribution of the source code, even though third parties are not
-        compelled to copy the source along with the object code.
-        
-          4. You may not copy, modify, sublicense, or distribute the Program
-        except as expressly provided under this License.  Any attempt
-        otherwise to copy, modify, sublicense or distribute the Program is
-        void, and will automatically terminate your rights under this License.
-        However, parties who have received copies, or rights, from you under
-        this License will not have their licenses terminated so long as such
-        parties remain in full compliance.
-        
-          5. You are not required to accept this License, since you have not
-        signed it.  However, nothing else grants you permission to modify or
-        distribute the Program or its derivative works.  These actions are
-        prohibited by law if you do not accept this License.  Therefore, by
-        modifying or distributing the Program (or any work based on the
-        Program), you indicate your acceptance of this License to do so, and
-        all its terms and conditions for copying, distributing or modifying
-        the Program or works based on it.
-        
-          6. Each time you redistribute the Program (or any work based on the
-        Program), the recipient automatically receives a license from the
-        original licensor to copy, distribute or modify the Program subject to
-        these terms and conditions.  You may not impose any further
-        restrictions on the recipients' exercise of the rights granted herein.
-        You are not responsible for enforcing compliance by third parties to
-        this License.
-        
-          7. If, as a consequence of a court judgment or allegation of patent
-        infringement or for any other reason (not limited to patent issues),
-        conditions are imposed on you (whether by court order, agreement or
-        otherwise) that contradict the conditions of this License, they do not
-        excuse you from the conditions of this License.  If you cannot
-        distribute so as to satisfy simultaneously your obligations under this
-        License and any other pertinent obligations, then as a consequence you
-        may not distribute the Program at all.  For example, if a patent
-        license would not permit royalty-free redistribution of the Program by
-        all those who receive copies directly or indirectly through you, then
-        the only way you could satisfy both it and this License would be to
-        refrain entirely from distribution of the Program.
-        
-        If any portion of this section is held invalid or unenforceable under
-        any particular circumstance, the balance of the section is intended to
-        apply and the section as a whole is intended to apply in other
-        circumstances.
-        
-        It is not the purpose of this section to induce you to infringe any
-        patents or other property right claims or to contest validity of any
-        such claims; this section has the sole purpose of protecting the
-        integrity of the free software distribution system, which is
-        implemented by public license practices.  Many people have made
-        generous contributions to the wide range of software distributed
-        through that system in reliance on consistent application of that
-        system; it is up to the author/donor to decide if he or she is willing
-        to distribute software through any other system and a licensee cannot
-        impose that choice.
-        
-        This section is intended to make thoroughly clear what is believed to
-        be a consequence of the rest of this License.
-        
-          8. If the distribution and/or use of the Program is restricted in
-        certain countries either by patents or by copyrighted interfaces, the
-        original copyright holder who places the Program under this License
-        may add an explicit geographical distribution limitation excluding
-        those countries, so that distribution is permitted only in or among
-        countries not thus excluded.  In such case, this License incorporates
-        the limitation as if written in the body of this License.
-        
-          9. The Free Software Foundation may publish revised and/or new versions
-        of the General Public License from time to time.  Such new versions will
-        be similar in spirit to the present version, but may differ in detail to
-        address new problems or concerns.
-        
-        Each version is given a distinguishing version number.  If the Program
-        specifies a version number of this License which applies to it and "any
-        later version", you have the option of following the terms and conditions
-        either of that version or of any later version published by the Free
-        Software Foundation.  If the Program does not specify a version number of
-        this License, you may choose any version ever published by the Free Software
-        Foundation.
-        
-          10. If you wish to incorporate parts of the Program into other free
-        programs whose distribution conditions are different, write to the author
-        to ask for permission.  For software which is copyrighted by the Free
-        Software Foundation, write to the Free Software Foundation; we sometimes
-        make exceptions for this.  Our decision will be guided by the two goals
-        of preserving the free status of all derivatives of our free software and
-        of promoting the sharing and reuse of software generally.
-        
-                                    NO WARRANTY
-        
-          11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-        FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-        OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-        PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-        OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-        MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-        TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-        PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-        REPAIR OR CORRECTION.
-        
-          12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-        WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-        REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-        INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-        OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-        TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-        YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-        PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-        POSSIBILITY OF SUCH DAMAGES.
-        
-                             END OF TERMS AND CONDITIONS
-        
-                    How to Apply These Terms to Your New Programs
-        
-          If you develop a new program, and you want it to be of the greatest
-        possible use to the public, the best way to achieve this is to make it
-        free software which everyone can redistribute and change under these terms.
-        
-          To do so, attach the following notices to the program.  It is safest
-        to attach them to the start of each source file to most effectively
-        convey the exclusion of warranty; and each file should have at least
-        the "copyright" line and a pointer to where the full notice is found.
-        
-            <one line to give the program's name and a brief idea of what it does.>
-            Copyright (C) <year>  <name of author>
-        
-            This program is free software; you can redistribute it and/or modify
-            it under the terms of the GNU General Public License as published by
-            the Free Software Foundation; either version 2 of the License, or
-            (at your option) any later version.
-        
-            This program is distributed in the hope that it will be useful,
-            but WITHOUT ANY WARRANTY; without even the implied warranty of
-            MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-            GNU General Public License for more details.
-        
-            You should have received a copy of the GNU General Public License along
-            with this program; if not, write to the Free Software Foundation, Inc.,
-            51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-        
-        Also add information on how to contact you by electronic and paper mail.
-        
-        If the program is interactive, make it output a short notice like this
-        when it starts in an interactive mode:
-        
-            Gnomovision version 69, Copyright (C) year name of author
-            Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-            This is free software, and you are welcome to redistribute it
-            under certain conditions; type `show c' for details.
-        
-        The hypothetical commands `show w' and `show c' should show the appropriate
-        parts of the General Public License.  Of course, the commands you use may
-        be called something other than `show w' and `show c'; they could even be
-        mouse-clicks or menu items--whatever suits your program.
-        
-        You should also get your employer (if you work as a programmer) or your
-        school, if any, to sign a "copyright disclaimer" for the program, if
-        necessary.  Here is a sample; alter the names:
-        
-          Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-          `Gnomovision' (which makes passes at compilers) written by James Hacker.
-        
-          <signature of Ty Coon>, 1 April 1989
-          Ty Coon, President of Vice
-        
-        This General Public License does not permit incorporating your program into
-        proprietary programs.  If your program is a subroutine library, you may
-        consider it more useful to permit linking proprietary applications with the
-        library.  If this is what you want to do, use the GNU Lesser General
-        Public License instead of this License.
-License-File: LICENSE
-Keywords: flake8,pep8,python
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Framework :: Flake8
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Software Development
-Classifier: Topic :: Software Development :: Quality Assurance
-Requires-Python: >=3.8
-Requires-Dist: flake8
-Provides-Extra: test
-Requires-Dist: pytest; extra == 'test'
-Description-Content-Type: text/x-rst
-
-.. -*- coding: utf-8 -*-
-
-.. image:: https://github.com/gforcada/flake8-builtins/actions/workflows/testing.yml/badge.svg?branch=main
-   :target: https://github.com/gforcada/flake8-builtins/actions/workflows/testing.yml
-
-.. image:: https://coveralls.io/repos/gforcada/flake8-builtins/badge.svg?branch=main
-   :target: https://coveralls.io/github/gforcada/flake8-builtins?branch=main
-
-Flake8 Builtins plugin
-======================
-Check for python builtins being used as variables or parameters.
-
-Imagine some code like this:
-
-.. code:: Python
-
-    def max_values(list, list2):
-        max = list[0]
-        for x in list:
-            if x > 0:
-                max = x
-
-        all_values = list()
-        all_values.append(max)
-
-        max = list2[0]
-        for x in list2:
-            if x > 0:
-                max = x
-        all_values.append(max)
-
-        return all_values
-
-    max_values([3, 4, 5, ], [5, 6, 7])
-
-The last statement is not returning ``[5, 7]`` as one would expect,
-instead is raising this exception::
-
-    Traceback (most recent call last):
-      File "test.py", line 17, in <module>
-        max_values([3,4,5], [4,5,6])
-      File "bla.py", line 6, in max_values
-        all_values = list()
-    TypeError: 'list' object is not callable
-
-**Why?** Because ``max_value`` function's first argument is ``list`` a Python builtin.
-Python allows to override them, but although could be useful in some really specific use cases,
-the general approach is to **not** do that as code then can suddenly break without a clear trace.
-
-Example
--------
-Given the following code:
-
-.. code:: Python
-
-    def my_method(object, list, dict):
-        max = 5
-        min = 3
-        zip = (4, 3)
-
-The following warnings are shown (via flake8)::
-
-   test.py:1:15: A002 argument "object" is shadowing a python builtin
-   test.py:1:23: A002 argument "list" is shadowing a python builtin
-   test.py:1:29: A002 argument "dict" is shadowing a python builtin
-   test.py:2:5: A001 variable "max" is shadowing a python builtin
-   test.py:3:5: A001 variable "min" is shadowing a python builtin
-   test.py:4:5: A001 variable "zip" is shadowing a python builtin
-
-Install
--------
-Install with pip::
-
-    $ python -m pip install flake8-builtins
-
-Options
--------
-
-One can use `--builtins-ignorelist` option, or configuration option,
-to ignore a custom list of builtins::
-
-    $ flake8 --builtins-ignorelist id,copyright *.py
-
-Requirements
-------------
-- Python 3.8, 3.9, 3.10, 3.11, and pypy3
-- flake8
-
-Rules
------
-
-A001:
-  A variable is shadowing a Python builtin.
-
-A002:
-  An argument is shadowing a Python builtin.
-
-A003:
-  A class attribute is shadowing a Python builtin.
-
-A004:
-  An import statement is shadowing a Python builtin.
-
-License
--------
-GPL 2.0

flake8_builtins-2.2.0/setup.cfg

@@ -1,9 +0,0 @@
-[zest.releaser]
-create-wheel = yes
-
-[check-manifest]
-ignore =
-    .installed.cfg
-
-[isort]
-profile = black