Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/pep8ext_naming.py
# -*- coding: utf-8 -*-
"""Checker of PEP-8 Naming Conventions."""
import sys
from collections import deque
from fnmatch import fnmatch
from functools import partial
from itertools import chain
from flake8_polyfill import options
try:
import ast
from ast import iter_child_nodes
except ImportError:
from flake8.util import ast, iter_child_nodes
__version__ = '0.10.0'
PYTHON_VERSION = sys.version_info[:3]
PY2 = PYTHON_VERSION[0] == 2
METACLASS_BASES = frozenset(('type', 'ABCMeta'))
# Node types which may contain class methods
METHOD_CONTAINER_NODES = {ast.If, ast.While, ast.For, ast.With}
FUNC_NODES = (ast.FunctionDef,)
if PY2:
METHOD_CONTAINER_NODES |= {ast.TryExcept, ast.TryFinally}
else:
METHOD_CONTAINER_NODES |= {ast.Try}
if PYTHON_VERSION > (3, 5):
FUNC_NODES += (ast.AsyncFunctionDef,)
METHOD_CONTAINER_NODES |= {ast.AsyncWith, ast.AsyncFor}
if PY2:
def _unpack_args(args):
ret = []
for arg in args:
if isinstance(arg, ast.Tuple):
ret.extend(_unpack_args(arg.elts))
else:
ret.append((arg, arg.id))
return ret
def get_arg_name_tuples(node):
return _unpack_args(node.args.args)
elif PYTHON_VERSION < (3, 8):
def get_arg_name_tuples(node):
groups = (node.args.args, node.args.kwonlyargs)
return [(arg, arg.arg) for args in groups for arg in args]
else:
def get_arg_name_tuples(node):
groups = (node.args.posonlyargs, node.args.args, node.args.kwonlyargs)
return [(arg, arg.arg) for args in groups for arg in args]
class _ASTCheckMeta(type):
def __init__(cls, class_name, bases, namespace):
try:
cls._checks.append(cls())
except AttributeError:
cls._checks = []
def _err(self, node, code, **kwargs):
lineno, col_offset = node.lineno, node.col_offset
if isinstance(node, ast.ClassDef):
if PYTHON_VERSION < (3, 8):
lineno += len(node.decorator_list)
col_offset += 6
elif isinstance(node, FUNC_NODES):
if PYTHON_VERSION < (3, 8):
lineno += len(node.decorator_list)
col_offset += 4
code_str = getattr(self, code)
if kwargs:
code_str = code_str.format(**kwargs)
return lineno, col_offset + 1, '%s %s' % (code, code_str), self
def _ignored(name, ignore):
return any(fnmatch(name, i) for i in ignore)
BaseASTCheck = _ASTCheckMeta('BaseASTCheck', (object,),
{'__doc__': "Base for AST Checks.", 'err': _err})
class _FunctionType(object):
CLASSMETHOD = 'classmethod'
STATICMETHOD = 'staticmethod'
FUNCTION = 'function'
METHOD = 'method'
_default_ignore_names = [
'setUp',
'tearDown',
'setUpClass',
'tearDownClass',
'setUpTestData',
'failureException',
'longMessage',
'maxDiff']
_default_classmethod_decorators = ['classmethod']
_default_staticmethod_decorators = ['staticmethod']
def _build_decorator_to_type(classmethod_decorators, staticmethod_decorators):
decorator_to_type = {}
for decorator in classmethod_decorators:
decorator_to_type[decorator] = _FunctionType.CLASSMETHOD
for decorator in staticmethod_decorators:
decorator_to_type[decorator] = _FunctionType.STATICMETHOD
return decorator_to_type
class NamingChecker(object):
"""Checker of PEP-8 Naming Conventions."""
name = 'naming'
version = __version__
decorator_to_type = _build_decorator_to_type(
_default_classmethod_decorators, _default_staticmethod_decorators)
ignore_names = frozenset(_default_ignore_names)
def __init__(self, tree, filename):
self.visitors = BaseASTCheck._checks
self.parents = deque()
self._node = tree
@classmethod
def add_options(cls, parser):
options.register(parser, '--ignore-names',
default=_default_ignore_names,
action='store',
type='string',
parse_from_config=True,
comma_separated_list=True,
help='List of names or glob patterns the pep8-naming '
'plugin should ignore. (Defaults to %default)')
options.register(parser, '--classmethod-decorators',
default=_default_classmethod_decorators,
action='store',
type='string',
parse_from_config=True,
comma_separated_list=True,
help='List of method decorators pep8-naming plugin '
'should consider classmethods (Defaults to '
'%default)')
options.register(parser, '--staticmethod-decorators',
default=_default_staticmethod_decorators,
action='store',
type='string',
parse_from_config=True,
comma_separated_list=True,
help='List of method decorators pep8-naming plugin '
'should consider staticmethods (Defaults to '
'%default)')
@classmethod
def parse_options(cls, options):
cls.ignore_names = frozenset(options.ignore_names)
cls.decorator_to_type = _build_decorator_to_type(
options.classmethod_decorators,
options.staticmethod_decorators)
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, FUNC_NODES):
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 not in self.decorator_to_type:
continue
meth = (len(node.value.args) == 1 and node.value.args[0])
if isinstance(meth, ast.Name):
late_decoration[meth.id] = self.decorator_to_type[func_name]
# If this class inherits from a known metaclass base class, it is
# itself a metaclass, and we'll consider all of it's methods to be
# classmethods.
bases = chain(
(b.id for b in cls_node.bases if isinstance(b, ast.Name)),
(b.attr for b in cls_node.bases if isinstance(b, ast.Attribute)),
)
ismetaclass = any(name for name in bases if name in METACLASS_BASES)
self.set_function_nodes_types(
iter_child_nodes(cls_node), ismetaclass, late_decoration)
def set_function_nodes_types(self, nodes, ismetaclass, late_decoration):
# iterate over all functions and tag them
for node in nodes:
if type(node) in METHOD_CONTAINER_NODES:
self.set_function_nodes_types(
iter_child_nodes(node), ismetaclass, late_decoration)
if not isinstance(node, FUNC_NODES):
continue
node.function_type = _FunctionType.METHOD
if node.name in ('__new__', '__init_subclass__') or ismetaclass:
node.function_type = _FunctionType.CLASSMETHOD
if node.name in late_decoration:
node.function_type = late_decoration[node.name]
elif node.decorator_list:
names = [self.decorator_to_type[d.id]
for d in node.decorator_list
if isinstance(d, ast.Name) and
d.id in self.decorator_to_type]
if names:
node.function_type = names[0]
@staticmethod
def find_global_defs(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.ClassDef,) + FUNC_NODES):
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.
"""
N801 = "class name '{name}' should use CapWords convention"
def visit_classdef(self, node, parents, ignore=None):
name = node.name
if _ignored(name, ignore):
return
name = name.strip('_')
if not name[:1].isupper() or '_' in name:
yield self.err(node, 'N801', name=name)
class FunctionNameCheck(BaseASTCheck):
"""
Function names should be lowercase, with words separated by underscores
as necessary to improve readability.
Functions *not* being 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.
"""
N802 = "function name '{name}' should be lowercase"
N807 = "function name '{name}' should not start and end with '__'"
def visit_functiondef(self, node, parents, ignore=None):
function_type = getattr(node, 'function_type', _FunctionType.FUNCTION)
name = node.name
if _ignored(name, ignore):
return
if name in ('__dir__', '__getattr__'):
return
if name.lower() != name:
yield self.err(node, 'N802', name=name)
if (function_type == _FunctionType.FUNCTION
and name[:2] == '__' and name[-2:] == '__'):
yield self.err(node, 'N807', name=name)
visit_asyncfunctiondef = visit_functiondef
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.
"""
N803 = "argument name '{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):
try:
return arg, arg.arg
except AttributeError: # PY2
return node, arg
for arg, name in arg_name(node.args.vararg), arg_name(node.args.kwarg):
if name is None or _ignored(name, ignore):
continue
if name.lower() != name:
yield self.err(arg, 'N803', name=name)
return
arg_name_tuples = get_arg_name_tuples(node)
if not arg_name_tuples:
return
arg0, name0 = arg_name_tuples[0]
function_type = getattr(node, 'function_type', _FunctionType.FUNCTION)
if function_type == _FunctionType.METHOD:
if name0 != 'self' and not _ignored(name0, ignore):
yield self.err(arg0, 'N805')
elif function_type == _FunctionType.CLASSMETHOD:
if name0 != 'cls' and not _ignored(name0, ignore):
yield self.err(arg0, 'N804')
for arg, name in arg_name_tuples:
if name.lower() != name and not _ignored(name, ignore):
yield self.err(arg, 'N803', name=name)
return
visit_asyncfunctiondef = visit_functiondef
class ImportAsCheck(BaseASTCheck):
"""
Don't change the naming convention via an import
"""
N811 = "constant '{name}' imported as non constant '{asname}'"
N812 = "lowercase '{name}' imported as non lowercase '{asname}'"
N813 = "camelcase '{name}' imported as lowercase '{asname}'"
N814 = "camelcase '{name}' imported as constant '{asname}'"
N817 = "camelcase '{name}' imported as acronym '{asname}'"
def visit_importfrom(self, node, parents, ignore=None):
for name in node.names:
asname = name.asname
if not asname:
continue
original_name = name.name
err_kwargs = {'name': original_name, 'asname': asname}
if original_name.isupper():
if not asname.isupper():
yield self.err(node, 'N811', **err_kwargs)
elif original_name.islower():
if asname.lower() != asname:
yield self.err(node, 'N812', **err_kwargs)
elif asname.islower():
yield self.err(node, 'N813', **err_kwargs)
elif asname.isupper():
if ''.join(filter(str.isupper, original_name)) == asname:
yield self.err(node, 'N817', **err_kwargs)
else:
yield self.err(node, 'N814', **err_kwargs)
visit_import = visit_importfrom
class VariablesCheck(BaseASTCheck):
"""
Class attributes and local variables in functions should be lowercase
"""
N806 = "variable '{name}' in function should be lowercase"
N815 = "variable '{name}' in class scope should not be mixedCase"
N816 = "variable '{name}' in global scope should not be mixedCase"
def _find_errors(self, assignment_target, parents, ignore):
for parent_func in reversed(parents):
if isinstance(parent_func, ast.ClassDef):
checker = self.class_variable_check
break
if isinstance(parent_func, FUNC_NODES):
checker = partial(self.function_variable_check, parent_func)
break
else:
checker = self.global_variable_check
for name in _extract_names(assignment_target):
if _ignored(name, ignore):
continue
error_code = checker(name)
if error_code:
yield self.err(assignment_target, error_code, name=name)
@staticmethod
def is_namedtupe(node_value):
if isinstance(node_value, ast.Call):
if isinstance(node_value.func, ast.Attribute):
if node_value.func.attr == 'namedtuple':
return True
elif isinstance(node_value.func, ast.Name):
if node_value.func.id == 'namedtuple':
return True
return False
def visit_assign(self, node, parents, ignore=None):
if self.is_namedtupe(node.value):
return
for target in node.targets:
for error in self._find_errors(target, parents, ignore):
yield error
def visit_namedexpr(self, node, parents, ignore):
if self.is_namedtupe(node.value):
return
for error in self._find_errors(node.target, parents, ignore):
yield error
visit_annassign = visit_namedexpr
def visit_with(self, node, parents, ignore):
if PY2:
for error in self._find_errors(
node.optional_vars, parents, ignore):
yield error
return
for item in node.items:
for error in self._find_errors(
item.optional_vars, parents, ignore):
yield error
visit_asyncwith = visit_with
def visit_for(self, node, parents, ignore):
for error in self._find_errors(node.target, parents, ignore):
yield error
visit_asyncfor = visit_for
def visit_excepthandler(self, node, parents, ignore):
if node.name:
for error in self._find_errors(node, parents, ignore):
yield error
def visit_generatorexp(self, node, parents, ignore):
for gen in node.generators:
for error in self._find_errors(gen.target, parents, ignore):
yield error
visit_listcomp = visit_dictcomp = visit_setcomp = visit_generatorexp
@staticmethod
def global_variable_check(name):
if is_mixed_case(name):
return 'N816'
@staticmethod
def class_variable_check(name):
if is_mixed_case(name):
return 'N815'
@staticmethod
def function_variable_check(func, var_name):
if var_name in func.global_names:
return None
if var_name.lower() == var_name:
return None
return 'N806'
def _extract_names(assignment_target):
"""Yield assignment_target ids."""
target_type = type(assignment_target)
if target_type is ast.Name:
yield assignment_target.id
elif target_type in (ast.Tuple, ast.List):
for element in assignment_target.elts:
element_type = type(element)
if element_type is ast.Name:
yield element.id
elif element_type in (ast.Tuple, ast.List):
for n in _extract_names(element):
yield n
elif not PY2 and element_type is ast.Starred: # PEP 3132
for n in _extract_names(element.value):
yield n
elif target_type is ast.ExceptHandler:
if PY2:
# Python 2 supports unpacking tuple exception values.
if isinstance(assignment_target.name, ast.Tuple):
for name in assignment_target.name.elts:
yield name.id
elif isinstance(assignment_target.name, ast.Attribute):
# Python 2 also supports assigning an exception to an attribute
# eg. except Exception as obj.attr
yield assignment_target.name.attr
else:
yield assignment_target.name.id
else:
yield assignment_target.name
def is_mixed_case(name):
return name.lower() != name and name.lstrip('_')[:1].islower()