Current File : //opt/cloudlinux/venv/lib64/python3.11/site-packages/pylint/checkers/non_ascii_names.py
# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
# For details: https://github.com/PyCQA/pylint/blob/main/LICENSE
# Copyright (c) https://github.com/PyCQA/pylint/blob/main/CONTRIBUTORS.txt
"""All alphanumeric unicode character are allowed in Python but due
to similarities in how they look they can be confused.
See: https://peps.python.org/pep-0672/#confusing-features
The following checkers are intended to make users are aware of these issues.
"""
from __future__ import annotations
from astroid import nodes
from pylint import constants, interfaces, lint
from pylint.checkers import base_checker, utils
NON_ASCII_HELP = (
"Used when the name contains at least one non-ASCII unicode character. "
"See https://peps.python.org/pep-0672/#confusing-features"
" for a background why this could be bad. \n"
"If your programming guideline defines that you are programming in "
"English, then there should be no need for non ASCII characters in "
"Python Names. If not you can simply disable this check."
)
class NonAsciiNameChecker(base_checker.BaseChecker):
"""A strict name checker only allowing ASCII.
Note: This check only checks Names, so it ignores the content of
docstrings and comments!
"""
msgs = {
"C2401": (
'%s name "%s" contains a non-ASCII character, consider renaming it.',
"non-ascii-name",
NON_ASCII_HELP,
{"old_names": [("C0144", "old-non-ascii-name")]},
),
# First %s will always be "file"
"W2402": (
'%s name "%s" contains a non-ASCII character.',
"non-ascii-file-name",
(
# Some = PyCharm at the time of writing didn't display the non_ascii_name_loł
# files. That's also why this is a warning and not only a convention!
"Under python 3.5, PEP 3131 allows non-ascii identifiers, but not non-ascii file names."
"Since Python 3.5, even though Python supports UTF-8 files, some editors or tools "
"don't."
),
),
# First %s will always be "module"
"C2403": (
'%s name "%s" contains a non-ASCII character, use an ASCII-only alias for import.',
"non-ascii-module-import",
NON_ASCII_HELP,
),
}
name = "NonASCII-Checker"
def _check_name(self, node_type: str, name: str | None, node: nodes.NodeNG) -> None:
"""Check whether a name is using non-ASCII characters."""
if name is None:
# For some nodes i.e. *kwargs from a dict, the name will be empty
return
if not str(name).isascii():
type_label = constants.HUMAN_READABLE_TYPES[node_type]
args = (type_label.capitalize(), name)
msg = "non-ascii-name"
# Some node types have customized messages
if node_type == "file":
msg = "non-ascii-file-name"
elif node_type == "module":
msg = "non-ascii-module-import"
self.add_message(msg, node=node, args=args, confidence=interfaces.HIGH)
@utils.only_required_for_messages("non-ascii-name", "non-ascii-file-name")
def visit_module(self, node: nodes.Module) -> None:
self._check_name("file", node.name.split(".")[-1], node)
@utils.only_required_for_messages("non-ascii-name")
def visit_functiondef(
self, node: nodes.FunctionDef | nodes.AsyncFunctionDef
) -> None:
self._check_name("function", node.name, node)
# Check argument names
arguments = node.args
# Check position only arguments
if arguments.posonlyargs:
for pos_only_arg in arguments.posonlyargs:
self._check_name("argument", pos_only_arg.name, pos_only_arg)
# Check "normal" arguments
if arguments.args:
for arg in arguments.args:
self._check_name("argument", arg.name, arg)
# Check key word only arguments
if arguments.kwonlyargs:
for kwarg in arguments.kwonlyargs:
self._check_name("argument", kwarg.name, kwarg)
visit_asyncfunctiondef = visit_functiondef
@utils.only_required_for_messages("non-ascii-name")
def visit_global(self, node: nodes.Global) -> None:
for name in node.names:
self._check_name("const", name, node)
@utils.only_required_for_messages("non-ascii-name")
def visit_assignname(self, node: nodes.AssignName) -> None:
"""Check module level assigned names."""
# The NameChecker from which this Checker originates knows a lot of different
# versions of variables, i.e. constants, inline variables etc.
# To simplify we use only `variable` here, as we don't need to apply different
# rules to different types of variables.
frame = node.frame()
if isinstance(frame, nodes.FunctionDef):
if node.parent in frame.body:
# Only perform the check if the assignment was done in within the body
# of the function (and not the function parameter definition
# (will be handled in visit_functiondef)
# or within a decorator (handled in visit_call)
self._check_name("variable", node.name, node)
elif isinstance(frame, nodes.ClassDef):
self._check_name("attr", node.name, node)
else:
# Possibilities here:
# - isinstance(node.assign_type(), nodes.Comprehension) == inlinevar
# - isinstance(frame, nodes.Module) == variable (constant?)
# - some other kind of assignment missed but still most likely a variable
self._check_name("variable", node.name, node)
@utils.only_required_for_messages("non-ascii-name")
def visit_classdef(self, node: nodes.ClassDef) -> None:
self._check_name("class", node.name, node)
for attr, anodes in node.instance_attrs.items():
if not any(node.instance_attr_ancestors(attr)):
self._check_name("attr", attr, anodes[0])
def _check_module_import(self, node: nodes.ImportFrom | nodes.Import) -> None:
for module_name, alias in node.names:
name = alias or module_name
self._check_name("module", name, node)
@utils.only_required_for_messages("non-ascii-name", "non-ascii-module-import")
def visit_import(self, node: nodes.Import) -> None:
self._check_module_import(node)
@utils.only_required_for_messages("non-ascii-name", "non-ascii-module-import")
def visit_importfrom(self, node: nodes.ImportFrom) -> None:
self._check_module_import(node)
@utils.only_required_for_messages("non-ascii-name")
def visit_call(self, node: nodes.Call) -> None:
"""Check if the used keyword args are correct."""
for keyword in node.keywords:
self._check_name("argument", keyword.arg, keyword)
def register(linter: lint.PyLinter) -> None:
linter.register_checker(NonAsciiNameChecker(linter))
Mini Shell