pep8-naming-0.3.3/0000755000076500000240000000000012544530354014557 5ustar icordascstaff00000000000000pep8-naming-0.3.3/pep8_naming.egg-info/0000755000076500000240000000000012544530354020456 5ustar icordascstaff00000000000000pep8-naming-0.3.3/pep8_naming.egg-info/dependency_links.txt0000644000076500000240000000000112544530354024524 0ustar icordascstaff00000000000000 pep8-naming-0.3.3/pep8_naming.egg-info/entry_points.txt0000644000076500000240000000021712544530354023754 0ustar icordascstaff00000000000000[flake8.extension] N8 = pep8ext_naming:NamingChecker [flint.extension] N80 = pep8ext_naming:NamingChecker N81 = pep8ext_naming:NamingChecker pep8-naming-0.3.3/pep8_naming.egg-info/not-zip-safe0000644000076500000240000000000112541343334022701 0ustar icordascstaff00000000000000 pep8-naming-0.3.3/pep8_naming.egg-info/PKG-INFO0000644000076500000240000001303512544530354021555 0ustar icordascstaff00000000000000Metadata-Version: 1.1 Name: pep8-naming Version: 0.3.3 Summary: Check PEP-8 naming conventions, plugin for flake8 Home-page: https://github.com/flintwork/pep8-naming Author: Florent Xicluna Author-email: florent.xicluna@gmail.com License: Expat license Description: PEP-8 Naming Conventions ======================== .. image:: https://badge.fury.io/py/pep8-naming.png :target: http://badge.fury.io/py/pep8-naming .. image:: https://travis-ci.org/flintwork/pep8-naming.png?branch=master :target: https://travis-ci.org/flintwork/pep8-naming .. image:: https://pypip.in/d/pep8-naming/badge.png :target: https://crate.io/packages/pep8-naming?version=latest Check the PEP-8 naming conventions. This module provides a plugin for ``flake8``, the Python code checker. (It replaces the plugin ``flint-naming`` for the ``flint`` checker.) Installation ------------ You can install, upgrade, uninstall ``pep8-naming`` with these commands:: $ pip install pep8-naming $ pip install --upgrade pep8-naming $ pip uninstall pep8-naming Plugin for Flake8 ----------------- When both ``flake8`` and ``pep8-naming`` are installed, the plugin is available in ``flake8``:: $ flake8 --version 2.0 (pep8: 1.4.3, pyflakes: 0.6.1, naming: 0.2) By default the plugin is enabled. These error codes are emitted: +------+-------------------------------------------------------+ | code | sample message | +======+=======================================================+ | N801 | class names should use CapWords convention | +------+-------------------------------------------------------+ | N802 | function name should be lowercase | +------+-------------------------------------------------------+ | N803 | argument name should be lowercase | +------+-------------------------------------------------------+ | N804 | first argument of a classmethod should be named 'cls' | +------+-------------------------------------------------------+ | N805 | first argument of a method should be named 'self' | +------+-------------------------------------------------------+ | N806 | variable in function should be lowercase | +------+-------------------------------------------------------+ +------+-------------------------------------------------------+ | N811 | constant imported as non constant | +------+-------------------------------------------------------+ | N812 | lowercase imported as non lowercase | +------+-------------------------------------------------------+ | N813 | camelcase imported as lowercase | +------+-------------------------------------------------------+ | N814 | camelcase imported as constant | +------+-------------------------------------------------------+ Changes ------- 0.3.3 - 2015-06-30 `````````````````` * Fix bug where ignored names were not properly split into a list. 0.3.2 - 2015-06-14 `````````````````` * Fix bug trying to call ``split`` on a list. 0.3.1 - 2015-06-14 `````````````````` * Fix optparse exception resulting from trying to register an option twice. 0.3.0 - 2015-06-14 `````````````````` * Relaxed N806 checking for use with namedtuples * Add ``--ignore-names`` which allows the user to specify a list of names to ignore. By default this includes ``setUp``, ``tearDown``, ``setUpClass``, and ``tearDownClass``. 0.2.2 - 2014-04-19 `````````````````` * Do not require ``setuptools`` in setup.py. It works around an issue with ``pip`` and Python 3. * ``__new__`` is now considered as ``classmethod`` implicitly * Run unit tests on travis-ci.org for python2.6, 2.7, 3.2, and 3.3 * Add unit tests and support running them with setup.py * Support Python 3.4 0.2.1 - 2013-02-22 `````````````````` * Do not require ``flake8`` 0.2 - 2013-02-22 ```````````````` * Rename project ``flint-naming`` to ``pep8-naming`` * Fix a crash when function argument is a tuple of tuples 0.1 - 2013-02-11 ```````````````` * First release Keywords: flake8 pep8 naming Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Software Development :: Quality Assurance pep8-naming-0.3.3/pep8_naming.egg-info/SOURCES.txt0000644000076500000240000000040312544530354022337 0ustar icordascstaff00000000000000README.rst pep8ext_naming.py setup.cfg setup.py pep8_naming.egg-info/PKG-INFO pep8_naming.egg-info/SOURCES.txt pep8_naming.egg-info/dependency_links.txt pep8_naming.egg-info/entry_points.txt pep8_naming.egg-info/not-zip-safe pep8_naming.egg-info/top_level.txtpep8-naming-0.3.3/pep8_naming.egg-info/top_level.txt0000644000076500000240000000001712544530354023206 0ustar icordascstaff00000000000000pep8ext_naming pep8-naming-0.3.3/pep8ext_naming.py0000644000076500000240000002421412544530256020063 0ustar icordascstaff00000000000000# -*- coding: utf-8 -*- """Checker of PEP-8 Naming Conventions.""" import re import sys from collections import deque try: import ast from ast import iter_child_nodes except ImportError: from flake8.util import ast, iter_child_nodes __version__ = '0.3.3' LOWERCASE_REGEX = re.compile(r'[_a-z][_a-z0-9]*$') UPPERCASE_REGEX = re.compile(r'[_A-Z][_A-Z0-9]*$') MIXEDCASE_REGEX = re.compile(r'_?[A-Z][a-zA-Z0-9]*$') SPLIT_IGNORED_RE = re.compile(r'[,\s]') if sys.version_info[0] < 3: def _unpack_args(args): ret = [] for arg in args: if isinstance(arg, ast.Tuple): ret.extend(_unpack_args(arg.elts)) else: ret.append(arg.id) return ret def get_arg_names(node): return _unpack_args(node.args.args) else: def get_arg_names(node): pos_args = [arg.arg for arg in node.args.args] kw_only = [arg.arg for arg in node.args.kwonlyargs] return pos_args + kw_only class _ASTCheckMeta(type): def __init__(self, class_name, bases, namespace): try: self._checks.append(self()) except AttributeError: self._checks = [] def _err(self, node, code): lineno, col_offset = node.lineno, node.col_offset if isinstance(node, ast.ClassDef): lineno += len(node.decorator_list) col_offset += 6 elif isinstance(node, ast.FunctionDef): lineno += len(node.decorator_list) col_offset += 4 return (lineno, col_offset, '%s %s' % (code, getattr(self, code)), self) BaseASTCheck = _ASTCheckMeta('BaseASTCheck', (object,), {'__doc__': "Base for AST Checks.", 'err': _err}) class NamingChecker(object): """Checker of PEP-8 Naming Conventions.""" name = 'naming' version = __version__ ignore_names = ['setUp', 'tearDown', 'setUpClass', 'tearDownClass'] def __init__(self, tree, filename): self.visitors = BaseASTCheck._checks self.parents = deque() self._node = tree @classmethod def add_options(cls, parser): ignored = ','.join(cls.ignore_names) parser.add_option('--ignore-names', default=ignored, action='store', type='string', help="Names that should be ignored.") parser.config_options.append('ignore-names') @classmethod def parse_options(cls, options): cls.ignore_names = SPLIT_IGNORED_RE.split(options.ignore_names) def run(self): return self.visit_tree(self._node) if self._node else () def visit_tree(self, node): for error in self.visit_node(node): yield error self.parents.append(node) for child in iter_child_nodes(node): for error in self.visit_tree(child): yield error self.parents.pop() def visit_node(self, node): if isinstance(node, ast.ClassDef): self.tag_class_functions(node) elif isinstance(node, ast.FunctionDef): self.find_global_defs(node) method = 'visit_' + node.__class__.__name__.lower() parents = self.parents ignore_names = self.ignore_names for visitor in self.visitors: visitor_method = getattr(visitor, method, None) if visitor_method is None: continue for error in visitor_method(node, parents, ignore_names): yield error def tag_class_functions(self, cls_node): """Tag functions if they are methods, classmethods, staticmethods""" # tries to find all 'old style decorators' like # m = staticmethod(m) late_decoration = {} for node in iter_child_nodes(cls_node): if not (isinstance(node, ast.Assign) and isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Name)): continue func_name = node.value.func.id if func_name in ('classmethod', 'staticmethod'): meth = (len(node.value.args) == 1 and node.value.args[0]) if isinstance(meth, ast.Name): late_decoration[meth.id] = func_name # iterate over all functions and tag them for node in iter_child_nodes(cls_node): if not isinstance(node, ast.FunctionDef): continue node.function_type = 'method' if node.name == '__new__': node.function_type = 'classmethod' if node.name in late_decoration: node.function_type = late_decoration[node.name] elif node.decorator_list: names = [d.id for d in node.decorator_list if isinstance(d, ast.Name) and d.id in ('classmethod', 'staticmethod')] if names: node.function_type = names[0] def find_global_defs(self, func_def_node): global_names = set() nodes_to_check = deque(iter_child_nodes(func_def_node)) while nodes_to_check: node = nodes_to_check.pop() if isinstance(node, ast.Global): global_names.update(node.names) if not isinstance(node, (ast.FunctionDef, ast.ClassDef)): nodes_to_check.extend(iter_child_nodes(node)) func_def_node.global_names = global_names class ClassNameCheck(BaseASTCheck): """ Almost without exception, class names use the CapWords convention. Classes for internal use have a leading underscore in addition. """ check = MIXEDCASE_REGEX.match N801 = "class names should use CapWords convention" def visit_classdef(self, node, parents, ignore=None): if not self.check(node.name): yield self.err(node, 'N801') class FunctionNameCheck(BaseASTCheck): """ Function names should be lowercase, with words separated by underscores as necessary to improve readability. Functions *not* beeing methods '__' in front and back are not allowed. mixedCase is allowed only in contexts where that's already the prevailing style (e.g. threading.py), to retain backwards compatibility. """ check = LOWERCASE_REGEX.match N802 = "function name should be lowercase" def visit_functiondef(self, node, parents, ignore=None): function_type = getattr(node, 'function_type', 'function') name = node.name if ignore and name in ignore: return if ((function_type == 'function' and '__' in (name[:2], name[-2:])) or not self.check(name)): yield self.err(node, 'N802') class FunctionArgNamesCheck(BaseASTCheck): """ The argument names of a function should be lowercase, with words separated by underscores. A classmethod should have 'cls' as first argument. A method should have 'self' as first argument. """ check = LOWERCASE_REGEX.match N803 = "argument name should be lowercase" N804 = "first argument of a classmethod should be named 'cls'" N805 = "first argument of a method should be named 'self'" def visit_functiondef(self, node, parents, ignore=None): def arg_name(arg): return getattr(arg, 'arg', arg) kwarg = arg_name(node.args.kwarg) if kwarg is not None: if not self.check(kwarg): yield self.err(node, 'N803') return vararg = arg_name(node.args.vararg) if vararg is not None: if not self.check(vararg): yield self.err(node, 'N803') return arg_names = get_arg_names(node) if not arg_names: return function_type = getattr(node, 'function_type', 'function') if function_type == 'method': if arg_names[0] != 'self': yield self.err(node, 'N805') elif function_type == 'classmethod': if arg_names[0] != 'cls': yield self.err(node, 'N804') for arg in arg_names: if not self.check(arg): yield self.err(node, 'N803') return class ImportAsCheck(BaseASTCheck): """ Don't change the naming convention via an import """ check_lower = LOWERCASE_REGEX.match check_upper = UPPERCASE_REGEX.match N811 = "constant imported as non constant" N812 = "lowercase imported as non lowercase" N813 = "camelcase imported as lowercase" N814 = "camelcase imported as constant" def visit_importfrom(self, node, parents, ignore=None): for name in node.names: if not name.asname: continue if self.check_upper(name.name): if not self.check_upper(name.asname): yield self.err(node, 'N811') elif self.check_lower(name.name): if not self.check_lower(name.asname): yield self.err(node, 'N812') elif self.check_lower(name.asname): yield self.err(node, 'N813') elif self.check_upper(name.asname): yield self.err(node, 'N814') class VariablesInFunctionCheck(BaseASTCheck): """ Local variables in functions should be lowercase """ check = LOWERCASE_REGEX.match N806 = "variable in function should be lowercase" def visit_assign(self, node, parents, ignore=None): for parent_func in reversed(parents): if isinstance(parent_func, ast.ClassDef): return if isinstance(parent_func, ast.FunctionDef): break else: return for target in node.targets: name = isinstance(target, ast.Name) and target.id if not name or name in parent_func.global_names: return if not self.check(name) and name[:1] != '_': if isinstance(node.value, ast.Call): if isinstance(node.value.func, ast.Attribute): if node.value.func.attr == 'namedtuple': return elif isinstance(node.value.func, ast.Name): if node.value.func.id == 'namedtuple': return yield self.err(target, 'N806') pep8-naming-0.3.3/PKG-INFO0000644000076500000240000001303512544530354015656 0ustar icordascstaff00000000000000Metadata-Version: 1.1 Name: pep8-naming Version: 0.3.3 Summary: Check PEP-8 naming conventions, plugin for flake8 Home-page: https://github.com/flintwork/pep8-naming Author: Florent Xicluna Author-email: florent.xicluna@gmail.com License: Expat license Description: PEP-8 Naming Conventions ======================== .. image:: https://badge.fury.io/py/pep8-naming.png :target: http://badge.fury.io/py/pep8-naming .. image:: https://travis-ci.org/flintwork/pep8-naming.png?branch=master :target: https://travis-ci.org/flintwork/pep8-naming .. image:: https://pypip.in/d/pep8-naming/badge.png :target: https://crate.io/packages/pep8-naming?version=latest Check the PEP-8 naming conventions. This module provides a plugin for ``flake8``, the Python code checker. (It replaces the plugin ``flint-naming`` for the ``flint`` checker.) Installation ------------ You can install, upgrade, uninstall ``pep8-naming`` with these commands:: $ pip install pep8-naming $ pip install --upgrade pep8-naming $ pip uninstall pep8-naming Plugin for Flake8 ----------------- When both ``flake8`` and ``pep8-naming`` are installed, the plugin is available in ``flake8``:: $ flake8 --version 2.0 (pep8: 1.4.3, pyflakes: 0.6.1, naming: 0.2) By default the plugin is enabled. These error codes are emitted: +------+-------------------------------------------------------+ | code | sample message | +======+=======================================================+ | N801 | class names should use CapWords convention | +------+-------------------------------------------------------+ | N802 | function name should be lowercase | +------+-------------------------------------------------------+ | N803 | argument name should be lowercase | +------+-------------------------------------------------------+ | N804 | first argument of a classmethod should be named 'cls' | +------+-------------------------------------------------------+ | N805 | first argument of a method should be named 'self' | +------+-------------------------------------------------------+ | N806 | variable in function should be lowercase | +------+-------------------------------------------------------+ +------+-------------------------------------------------------+ | N811 | constant imported as non constant | +------+-------------------------------------------------------+ | N812 | lowercase imported as non lowercase | +------+-------------------------------------------------------+ | N813 | camelcase imported as lowercase | +------+-------------------------------------------------------+ | N814 | camelcase imported as constant | +------+-------------------------------------------------------+ Changes ------- 0.3.3 - 2015-06-30 `````````````````` * Fix bug where ignored names were not properly split into a list. 0.3.2 - 2015-06-14 `````````````````` * Fix bug trying to call ``split`` on a list. 0.3.1 - 2015-06-14 `````````````````` * Fix optparse exception resulting from trying to register an option twice. 0.3.0 - 2015-06-14 `````````````````` * Relaxed N806 checking for use with namedtuples * Add ``--ignore-names`` which allows the user to specify a list of names to ignore. By default this includes ``setUp``, ``tearDown``, ``setUpClass``, and ``tearDownClass``. 0.2.2 - 2014-04-19 `````````````````` * Do not require ``setuptools`` in setup.py. It works around an issue with ``pip`` and Python 3. * ``__new__`` is now considered as ``classmethod`` implicitly * Run unit tests on travis-ci.org for python2.6, 2.7, 3.2, and 3.3 * Add unit tests and support running them with setup.py * Support Python 3.4 0.2.1 - 2013-02-22 `````````````````` * Do not require ``flake8`` 0.2 - 2013-02-22 ```````````````` * Rename project ``flint-naming`` to ``pep8-naming`` * Fix a crash when function argument is a tuple of tuples 0.1 - 2013-02-11 ```````````````` * First release Keywords: flake8 pep8 naming Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Software Development :: Quality Assurance pep8-naming-0.3.3/README.rst0000644000076500000240000000740312544530241016245 0ustar icordascstaff00000000000000PEP-8 Naming Conventions ======================== .. image:: https://badge.fury.io/py/pep8-naming.png :target: http://badge.fury.io/py/pep8-naming .. image:: https://travis-ci.org/flintwork/pep8-naming.png?branch=master :target: https://travis-ci.org/flintwork/pep8-naming .. image:: https://pypip.in/d/pep8-naming/badge.png :target: https://crate.io/packages/pep8-naming?version=latest Check the PEP-8 naming conventions. This module provides a plugin for ``flake8``, the Python code checker. (It replaces the plugin ``flint-naming`` for the ``flint`` checker.) Installation ------------ You can install, upgrade, uninstall ``pep8-naming`` with these commands:: $ pip install pep8-naming $ pip install --upgrade pep8-naming $ pip uninstall pep8-naming Plugin for Flake8 ----------------- When both ``flake8`` and ``pep8-naming`` are installed, the plugin is available in ``flake8``:: $ flake8 --version 2.0 (pep8: 1.4.3, pyflakes: 0.6.1, naming: 0.2) By default the plugin is enabled. These error codes are emitted: +------+-------------------------------------------------------+ | code | sample message | +======+=======================================================+ | N801 | class names should use CapWords convention | +------+-------------------------------------------------------+ | N802 | function name should be lowercase | +------+-------------------------------------------------------+ | N803 | argument name should be lowercase | +------+-------------------------------------------------------+ | N804 | first argument of a classmethod should be named 'cls' | +------+-------------------------------------------------------+ | N805 | first argument of a method should be named 'self' | +------+-------------------------------------------------------+ | N806 | variable in function should be lowercase | +------+-------------------------------------------------------+ +------+-------------------------------------------------------+ | N811 | constant imported as non constant | +------+-------------------------------------------------------+ | N812 | lowercase imported as non lowercase | +------+-------------------------------------------------------+ | N813 | camelcase imported as lowercase | +------+-------------------------------------------------------+ | N814 | camelcase imported as constant | +------+-------------------------------------------------------+ Changes ------- 0.3.3 - 2015-06-30 `````````````````` * Fix bug where ignored names were not properly split into a list. 0.3.2 - 2015-06-14 `````````````````` * Fix bug trying to call ``split`` on a list. 0.3.1 - 2015-06-14 `````````````````` * Fix optparse exception resulting from trying to register an option twice. 0.3.0 - 2015-06-14 `````````````````` * Relaxed N806 checking for use with namedtuples * Add ``--ignore-names`` which allows the user to specify a list of names to ignore. By default this includes ``setUp``, ``tearDown``, ``setUpClass``, and ``tearDownClass``. 0.2.2 - 2014-04-19 `````````````````` * Do not require ``setuptools`` in setup.py. It works around an issue with ``pip`` and Python 3. * ``__new__`` is now considered as ``classmethod`` implicitly * Run unit tests on travis-ci.org for python2.6, 2.7, 3.2, and 3.3 * Add unit tests and support running them with setup.py * Support Python 3.4 0.2.1 - 2013-02-22 `````````````````` * Do not require ``flake8`` 0.2 - 2013-02-22 ```````````````` * Rename project ``flint-naming`` to ``pep8-naming`` * Fix a crash when function argument is a tuple of tuples 0.1 - 2013-02-11 ```````````````` * First release pep8-naming-0.3.3/setup.cfg0000644000076500000240000000012212544530354016373 0ustar icordascstaff00000000000000[wheel] universal = 1 [egg_info] tag_date = 0 tag_build = tag_svn_revision = 0 pep8-naming-0.3.3/setup.py0000644000076500000240000000406112541345525016273 0ustar icordascstaff00000000000000# -*- coding: utf-8 -*- from __future__ import with_statement from setuptools import setup from setuptools.command.test import test as TestCommand def get_version(fname='pep8ext_naming.py'): with open(fname) as f: for line in f: if line.startswith('__version__'): return eval(line.split('=')[-1]) def get_long_description(): descr = [] for fname in ('README.rst',): with open(fname) as f: descr.append(f.read()) return '\n\n'.join(descr) class RunTests(TestCommand): def finalize_options(self): TestCommand.finalize_options(self) self.test_args = [] self.test_suite = True def run_tests(self): import run_tests import sys errno = run_tests.main() sys.exit(errno) setup( name='pep8-naming', version=get_version(), description="Check PEP-8 naming conventions, plugin for flake8", long_description=get_long_description(), keywords='flake8 pep8 naming', author='Florent Xicluna', author_email='florent.xicluna@gmail.com', url='https://github.com/flintwork/pep8-naming', license='Expat license', py_modules=['pep8ext_naming'], zip_safe=False, entry_points={ 'flake8.extension': [ 'N8 = pep8ext_naming:NamingChecker', ], # Backward compatibility for Flint (now merged into Flake8) 'flint.extension': [ 'N80 = pep8ext_naming:NamingChecker', 'N81 = pep8ext_naming:NamingChecker', ], }, classifiers=[ 'Development Status :: 3 - Alpha', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Software Development :: Quality Assurance', ], cmdclass={'test': RunTests}, )