"""Augmentations.""" # pylint: disable=invalid-name import functools import itertools from astroid import InferenceError from astroid.nodes import Attribute, ClassDef, ImportFrom from astroid.nodes.scoped_nodes import ClassDef as ScopedClass from astroid.nodes.scoped_nodes import Module from astroid.objects import Super from django import VERSION as django_version from django.utils import termcolors from django.views.generic.base import ContextMixin, RedirectView, View from django.views.generic.dates import ( DateMixin, DayMixin, MonthMixin, WeekMixin, YearMixin, ) from django.views.generic.detail import ( SingleObjectMixin, SingleObjectTemplateResponseMixin, TemplateResponseMixin, ) from django.views.generic.edit import DeletionMixin, FormMixin, ModelFormMixin from django.views.generic.list import ( MultipleObjectMixin, MultipleObjectTemplateResponseMixin, ) from pylint.checkers.base import DocStringChecker, NameChecker from pylint.checkers.classes import ClassChecker from pylint.checkers.design_analysis import MisdesignChecker from pylint.checkers.newstyle import NewStyleConflictChecker from pylint.checkers.typecheck import TypeChecker from pylint.checkers.variables import ScopeConsumer, VariablesChecker from pylint_plugin_utils import augment_visit, suppress_message from pylint_django.utils import PY3, node_is_subclass # Note: it would have been nice to import the Manager object from Django and # get its attributes that way - and this used to be the method - but unfortunately # there's no guarantee that Django is properly configured at that stage, and importing # anything from the django.db package causes an ImproperlyConfigured exception. # Therefore we'll fall back on a hard-coded list of attributes which won't be as accurate, # but this is not 100% accurate anyway. MANAGER_ATTRS = { "none", "all", "count", "dates", "distinct", "extra", "get", "get_or_create", "update_or_create", "get_queryset", "create", "bulk_create", "filter", "aggregate", "annotate", "complex_filter", "exclude", "in_bulk", "iterator", "latest", "order_by", "select_for_update", "select_related", "prefetch_related", "values", "values_list", "update", "reverse", "defer", "only", "using", "exists", } QS_ATTRS = { "filter", "exclude", "annotate", "order_by", "reverse", "distinct", "values", "values_list", "dates", "datetimes", "none", "all", "select_related", "prefetch_related", "extra", "defer", "only", "using", "select_for_update", "raw", "get", "create", "get_or_create", "update_or_create", "bulk_create", "count", "in_bulk", "iterator", "latest", "earliest", "first", "last", "aggregate", "exists", "update", "delete", "as_manager", "expression", "output_field", } MODELADMIN_ATTRS = { # options "actions", "actions_on_top", "actions_on_bottom", "actions_selection_counter", "date_hierarchy", "empty_value_display", "exclude", "fields", "fieldsets", "filter_horizontal", "filter_vertical", "form", "formfield_overrides", "inlines", "list_display", "list_display_links", "list_editable", "list_filter", "list_max_show_all", "list_per_page", "list_select_related", "ordering", "paginator", "prepopulated_fields", "preserve_filters", "radio_fields", "raw_id_fields", "readonly_fields", "save_as", "save_on_top", "search_fields", "show_full_result_count", "view_on_site", # template options "add_form_template", "change_form_template", "change_list_template", "delete_confirmation_template", "delete_selected_confirmation_template", "object_history_template", } MODEL_ATTRS = { "id", "DoesNotExist", "MultipleObjectsReturned", "_base_manager", "_default_manager", "_meta", "delete", "get_next_by_date", "get_previous_by_date", "objects", "save", } FIELD_ATTRS = { "null", "blank", "choices", "db_column", "db_index", "db_tablespace", "default", "editable", "error_messages", "help_text", "primary_key", "unique", "unique_for_date", "unique_for_month", "unique_for_year", "verbose_name", "validators", } CHAR_FIELD_ATTRS = { "max_length", } DATE_FIELD_ATTRS = { "auto_now", "auto_now_add", } DECIMAL_FIELD_ATTRS = { "max_digits", "decimal_places", } FILE_FIELD_ATTRS = { "upload_to", "storage", } IMAGE_FIELD_ATTRS = { "height_field", "width_field", } IP_FIELD_ATTRS = { "protocol", "unpack_ipv4", } SLUG_FIELD_ATTRS = { "allow_unicode", } FOREIGNKEY_FIELD_ATTRS = { "limit_choices_to", "related_name", "related_query_name", "to_field", "db_constraint", "swappable", } MANYTOMANY_FIELD_ATTRS = { "add", "clear", "related_name", "related_query_name", "remove", "set", "limit_choices_to", "symmetrical", "through", "through_fields", "db_table", "db_constraint", "swappable", } ONETOONE_FIELD_ATTRS = { "parent_link", } STYLE_ATTRS = set(itertools.chain.from_iterable(termcolors.PALETTES.values())) VIEW_ATTRS = { ( ( f"{cls.__module__}.{cls.__name__}", f".{cls.__name__}", ), tuple(cls.__dict__.keys()), ) for cls in ( View, RedirectView, ContextMixin, DateMixin, DayMixin, MonthMixin, WeekMixin, YearMixin, SingleObjectMixin, SingleObjectTemplateResponseMixin, TemplateResponseMixin, DeletionMixin, FormMixin, ModelFormMixin, MultipleObjectMixin, MultipleObjectTemplateResponseMixin, ) } FORM_ATTRS = { "declared_fields", } def ignore_import_warnings_for_related_fields(orig_method, self, node): """ Replaces the leave_module method on the VariablesChecker class to prevent unused-import warnings which are caused by the ForeignKey and OneToOneField transformations. By replacing the nodes in the AST with their type rather than the django field, imports of the form 'from django.db.models import OneToOneField' raise an unused-import warning """ consumer = self._to_consume[0] # pylint: disable=W0212 # we can disable this warning ('Access to a protected member _to_consume of a client class') # as it's not actually a client class, but rather, this method is being monkey patched # onto the class and so the access is valid new_things = {} iterat = consumer.to_consume.items if PY3 else consumer.to_consume.iteritems for name, stmts in iterat(): if isinstance(stmts[0], ImportFrom): if any(n[0] in ("ForeignKey", "OneToOneField") for n in stmts[0].names): continue new_things[name] = stmts # ScopeConsumer changed between pylint 2.12 and 2.13 # see https://github.com/PyCQA/pylint/issues/5970#issuecomment-1078778393 if hasattr(consumer, "consumed_uncertain"): # this is pylint >= 2.13, and the ScopeConsumer tuple has an additional field sc_args = (new_things, consumer.consumed, consumer.consumed_uncertain, consumer.scope_type) else: # this is <2.13 and does not have the consumer_uncertain field sc_args = (new_things, consumer.consumed, consumer.scope_type) consumer._atomic = ScopeConsumer(*sc_args) # pylint: disable=W0212 self._to_consume = [consumer] # pylint: disable=W0212 return orig_method(self, node) def foreign_key_sets(chain, node): """ When a Django model has a ForeignKey to another model, the target of the foreign key gets a '<modelname>_set' attribute for accessing a queryset of the model owning the foreign key - eg: class ModelA(models.Model): pass class ModelB(models.Model): a = models.ForeignKey(ModelA) Now, ModelA instances will have a modelb_set attribute. It's also possible to explicitly name the relationship using the related_name argument to the ForeignKey constructor. As it's impossible to know this without inspecting all models before processing, we'll instead do a "best guess" approach and see if the attribute being accessed goes on to be used as a queryset. This is via 'duck typing': if the method called on the attribute being accessed is something we might find in a queryset, we'll warn. """ quack = False if node.attrname in MANAGER_ATTRS or node.attrname.endswith("_set"): # if this is a X_set method, that's a pretty strong signal that this is the default # Django name, rather than one set by related_name quack = True else: # we will if isinstance(node.parent, Attribute): func_name = getattr(node.parent, "attrname", None) if func_name in MANAGER_ATTRS: quack = True if quack: children = list(node.get_children()) for child in children: try: inferred_cls = child.inferred() except InferenceError: pass else: for cls in inferred_cls: if node_is_subclass( cls, "django.db.models.manager.Manager", "django.db.models.base.Model", ".Model", "django.db.models.fields.related.ForeignObject", ): # This means that we are looking at a subclass of models.Model # and something is trying to access a <something>_set attribute. # Since this could exist, we will return so as not to raise an # error. return chain() def foreign_key_ids(chain, node): if node.attrname.endswith("_id"): return chain() def is_model_admin_subclass(node): """Checks that node is derivative of ModelAdmin class.""" if node.name[-5:] != "Admin" or isinstance(node.parent, ClassDef): return False return node_is_subclass(node, "django.contrib.admin.options.ModelAdmin") def is_model_media_subclass(node): """Checks that node is derivative of Media class.""" if node.name != "Media" or not isinstance(node.parent, ClassDef): return False parents = ( "django.contrib.admin.options.ModelAdmin", "django.forms.widgets.Media", "django.db.models.base.Model", ".Model", # for the transformed version used in this plugin "django.forms.forms.Form", ".Form", "django.forms.widgets.Widget", ".Widget", "django.forms.models.ModelForm", ".ModelForm", ) return node_is_subclass(node.parent, *parents) def is_model_meta_subclass(node): """Checks that node is derivative of Meta class.""" if node.name != "Meta" or not isinstance(node.parent, ClassDef): return False parents = ( ".Model", # for the transformed version used here "django.db.models.base.Model", ".Form", "django.forms.forms.Form", ".ModelForm", "django.forms.models.ModelForm", "rest_framework.serializers.BaseSerializer", "rest_framework.generics.GenericAPIView", "rest_framework.viewsets.ReadOnlyModelViewSet", "rest_framework.viewsets.ModelViewSet", "django_filters.filterset.FilterSet", "factory.django.DjangoModelFactory", ) return node_is_subclass(node.parent, *parents) def is_model_factory(node): """Checks that node is derivative of DjangoModelFactory or SubFactory class.""" try: parent_classes = node.expr.inferred() except: # noqa: E722, pylint: disable=bare-except return False parents = ( "factory.declarations.LazyFunction", "factory.declarations.SubFactory", "factory.django.DjangoModelFactory", ) for parent_class in parent_classes: try: if parent_class.qname() in parents: return True if node_is_subclass(parent_class, *parents): return True except AttributeError: continue return False def is_factory_post_generation_method(node): if not node.decorators: return False for decorator in node.decorators.get_children(): try: inferred = decorator.inferred() except InferenceError: continue for target in inferred: if target.qname() == "factory.helpers.post_generation": return True return False def is_model_mpttmeta_subclass(node): """Checks that node is derivative of MPTTMeta class.""" if node.name != "MPTTMeta" or not isinstance(node.parent, ClassDef): return False parents = ( "django.db.models.base.Model", ".Model", # for the transformed version used in this plugin "django.forms.forms.Form", ".Form", "django.forms.models.ModelForm", ".ModelForm", ) return node_is_subclass(node.parent, *parents) def _attribute_is_magic(node, attrs, parents): """Checks that node is an attribute used inside one of allowed parents""" if node.attrname not in attrs: return False if not node.last_child(): return False try: for cls in node.last_child().inferred(): if isinstance(cls, Super): cls = cls._self_class # pylint: disable=protected-access if node_is_subclass(cls, *parents) or cls.qname() in parents: return True except InferenceError: pass return False def is_style_attribute(node): parents = ("django.core.management.color.Style",) return _attribute_is_magic(node, STYLE_ATTRS, parents) def is_manager_attribute(node): """Checks that node is attribute of Manager or QuerySet class.""" parents = ( "django.db.models.manager.Manager", ".Manager", "factory.base.BaseFactory.build", "django.db.models.query.QuerySet", ".QuerySet", ) return _attribute_is_magic(node, MANAGER_ATTRS.union(QS_ATTRS), parents) def is_admin_attribute(node): """Checks that node is attribute of BaseModelAdmin.""" parents = ("django.contrib.admin.options.BaseModelAdmin", ".BaseModelAdmin") return _attribute_is_magic(node, MODELADMIN_ATTRS, parents) def is_model_attribute(node): """Checks that node is attribute of Model.""" parents = ("django.db.models.base.Model", ".Model") return _attribute_is_magic(node, MODEL_ATTRS, parents) def is_field_attribute(node): """Checks that node is attribute of Field.""" parents = ("django.db.models.fields.Field", ".Field") return _attribute_is_magic(node, FIELD_ATTRS, parents) def is_charfield_attribute(node): """Checks that node is attribute of CharField.""" parents = ("django.db.models.fields.CharField", ".CharField") return _attribute_is_magic(node, CHAR_FIELD_ATTRS, parents) def is_datefield_attribute(node): """Checks that node is attribute of DateField.""" parents = ("django.db.models.fields.DateField", ".DateField") return _attribute_is_magic(node, DATE_FIELD_ATTRS, parents) def is_decimalfield_attribute(node): """Checks that node is attribute of DecimalField.""" parents = ("django.db.models.fields.DecimalField", ".DecimalField") return _attribute_is_magic(node, DECIMAL_FIELD_ATTRS, parents) def is_filefield_attribute(node): """Checks that node is attribute of FileField.""" parents = ("django.db.models.fields.files.FileField", ".FileField") return _attribute_is_magic(node, FILE_FIELD_ATTRS, parents) def is_imagefield_attribute(node): """Checks that node is attribute of ImageField.""" parents = ("django.db.models.fields.files.ImageField", ".ImageField") return _attribute_is_magic(node, IMAGE_FIELD_ATTRS, parents) def is_ipfield_attribute(node): """Checks that node is attribute of GenericIPAddressField.""" parents = ( "django.db.models.fields.GenericIPAddressField", ".GenericIPAddressField", ) return _attribute_is_magic(node, IP_FIELD_ATTRS, parents) def is_slugfield_attribute(node): """Checks that node is attribute of SlugField.""" parents = ("django.db.models.fields.SlugField", ".SlugField") return _attribute_is_magic(node, SLUG_FIELD_ATTRS, parents) def is_foreignkeyfield_attribute(node): """Checks that node is attribute of ForeignKey.""" parents = ("django.db.models.fields.related.ForeignKey", ".ForeignKey") return _attribute_is_magic(node, FOREIGNKEY_FIELD_ATTRS, parents) def is_manytomanyfield_attribute(node): """Checks that node is attribute of ManyToManyField.""" parents = ("django.db.models.fields.related.ManyToManyField", ".ManyToManyField") return _attribute_is_magic(node, MANYTOMANY_FIELD_ATTRS, parents) def is_onetoonefield_attribute(node): """Checks that node is attribute of OneToOneField.""" parents = ("django.db.models.fields.related.OneToOneField", ".OneToOneField") return _attribute_is_magic(node, ONETOONE_FIELD_ATTRS, parents) def is_form_attribute(node): """Checks that node is attribute of Form.""" parents = ("django.forms.forms.Form", "django.forms.models.ModelForm") return _attribute_is_magic(node, FORM_ATTRS, parents) def is_model_test_case_subclass(node): """Checks that node is derivative of TestCase class.""" if not node.name.endswith("Test") and not isinstance(node.parent, ClassDef): return False return node_is_subclass(node, "django.test.testcases.TestCase") class IsAttribute: # pylint: disable=too-few-public-methods def __init__(self, parents, attrs): self.parents = parents self.attrs = attrs def __call__(self, node): return _attribute_is_magic(node, self.attrs, self.parents) def is_model_view_subclass_method_shouldnt_be_function(node): """Checks that node is a default http method (i.e get, post, put, and more) of the View class.""" if node.name not in View.http_method_names: return False parent = node.parent while parent and not isinstance(parent, ScopedClass): parent = parent.parent subclass = ( "django.views.View", "django.views.generic.View", "django.views.generic.base.View", ) return parent is not None and node_is_subclass(parent, *subclass) def ignore_unused_argument_warnings_for_request(orig_method, self, stmt, name): """ Ignore unused-argument warnings for function arguments named "request". The signature of Django view functions require the request argument but it is okay if the request is not used. This function should be used as a wrapper for the `VariablesChecker._is_name_ignored` method. """ if name in ("request", "args", "kwargs"): return True return orig_method(self, stmt, name) def is_model_field_display_method(node): """Accept model's fields with get_*_display names.""" if not node.attrname.endswith("_display"): return False if not node.attrname.startswith("get_"): return False if node.last_child(): # TODO: could validate the names of the fields on the model rather than # blindly accepting get_*_display try: for cls in node.last_child().inferred(): if node_is_subclass(cls, "django.db.models.base.Model", ".Model"): return True except InferenceError: return False return False def is_model_media_valid_attributes(node): """Suppress warnings for valid attributes of Media class.""" if node.name not in ("js",): return False parent = node.parent while parent and not isinstance(parent, ScopedClass): parent = parent.parent if parent is None or parent.name != "Media": return False return True def is_templatetags_module_valid_constant(node): """Suppress warnings for valid constants in templatetags module.""" if node.name not in ("register",): return False parent = node.parent while not isinstance(parent, Module): parent = parent.parent if "templatetags." not in parent.name: return False return True def is_urls_module_valid_constant(node): """Suppress warnings for valid constants in urls module.""" if node.name not in ("urlpatterns", "app_name"): return False parent = node.parent while not isinstance(parent, Module): parent = parent.parent if not parent.name.endswith("urls"): return False return True def allow_meta_protected_access(node): if django_version >= (1, 8): return node.attrname == "_meta" return False class IsClass: # pylint: disable=too-few-public-methods def __init__(self, class_name): self.class_name = class_name def __call__(self, node): return node_is_subclass(node, self.class_name) def wrap(orig_method, with_method): @functools.wraps(orig_method) def wrap_func(*args, **kwargs): return with_method(orig_method, *args, **kwargs) return wrap_func def is_wsgi_application(node): frame = node.frame() return ( node.name == "application" and isinstance(frame, Module) and ( frame.name == "asgi" or frame.path[0].endswith("asgi.py") or frame.file.endswith("asgi.py") or frame.name == "wsgi" or frame.path[0].endswith("wsgi.py") or frame.file.endswith("wsgi.py") ) ) # Compat helpers def pylint_newstyle_classdef_compat(linter, warning_name, augment): if not hasattr(NewStyleConflictChecker, "visit_classdef"): return suppress_message( linter, getattr(NewStyleConflictChecker, "visit_classdef"), warning_name, augment, ) def apply_wrapped_augmentations(): """ Apply augmentation and suppression rules through monkey patching of pylint. """ # NOTE: The monkey patching is done with wrap and needs to be done in a thread safe manner to support the # parallel option of pylint (-j). # This is achieved by comparing __name__ of the monkey patched object to the original value and only patch it if # these are equal. # Unused argument 'request' (get, post) current_is_name_ignored = VariablesChecker._is_name_ignored # pylint: disable=protected-access if current_is_name_ignored.__name__ == "_is_name_ignored": # pylint: disable=protected-access VariablesChecker._is_name_ignored = wrap(current_is_name_ignored, ignore_unused_argument_warnings_for_request) # ForeignKey and OneToOneField current_leave_module = VariablesChecker.leave_module if current_leave_module.__name__ == "leave_module": # current_leave_module is not wrapped # Two threads may hit the next assignment concurrently, but the result is the same VariablesChecker.leave_module = wrap(current_leave_module, ignore_import_warnings_for_related_fields) # VariablesChecker.leave_module is now wrapped # else VariablesChecker.leave_module is already wrapped # augment things def apply_augmentations(linter): """Apply augmentation and suppression rules.""" augment_visit(linter, TypeChecker.visit_attribute, foreign_key_sets) augment_visit(linter, TypeChecker.visit_attribute, foreign_key_ids) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_model_field_display_method) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_style_attribute) suppress_message( linter, NameChecker.visit_assignname, "invalid-name", is_urls_module_valid_constant, ) # supress errors when accessing magical class attributes suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_manager_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_admin_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_model_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_field_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_charfield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_datefield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_decimalfield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_filefield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_imagefield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_ipfield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_slugfield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_foreignkeyfield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_manytomanyfield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_onetoonefield_attribute) suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_form_attribute) for parents, attrs in VIEW_ATTRS: suppress_message( linter, TypeChecker.visit_attribute, "no-member", IsAttribute(parents, attrs), ) # formviews have too many ancestors, there's nothing the user of the library can do about that suppress_message( linter, MisdesignChecker.visit_classdef, "too-many-ancestors", IsClass("django.views.generic.edit.FormView"), ) # class-based generic views just have a longer inheritance chain suppress_message( linter, MisdesignChecker.visit_classdef, "too-many-ancestors", IsClass("django.views.generic.detail.BaseDetailView"), ) suppress_message( linter, MisdesignChecker.visit_classdef, "too-many-ancestors", IsClass("django.views.generic.edit.ProcessFormView"), ) # model forms have no __init__ method anywhere in their bases suppress_message( linter, ClassChecker.visit_classdef, "W0232", IsClass("django.forms.models.ModelForm"), ) # Meta suppress_message( linter, DocStringChecker.visit_classdef, "missing-docstring", is_model_meta_subclass, ) pylint_newstyle_classdef_compat(linter, "old-style-class", is_model_meta_subclass) suppress_message(linter, ClassChecker.visit_classdef, "no-init", is_model_meta_subclass) suppress_message( linter, MisdesignChecker.leave_classdef, "too-few-public-methods", is_model_meta_subclass, ) suppress_message( linter, ClassChecker.visit_attribute, "protected-access", allow_meta_protected_access, ) # Media suppress_message(linter, NameChecker.visit_assignname, "C0103", is_model_media_valid_attributes) suppress_message( linter, DocStringChecker.visit_classdef, "missing-docstring", is_model_media_subclass, ) pylint_newstyle_classdef_compat(linter, "old-style-class", is_model_media_subclass) suppress_message(linter, ClassChecker.visit_classdef, "no-init", is_model_media_subclass) suppress_message( linter, MisdesignChecker.leave_classdef, "too-few-public-methods", is_model_media_subclass, ) # Admin # Too many public methods (40+/20) # TODO: Count public methods of django.contrib.admin.options.ModelAdmin and increase # MisdesignChecker.config.max_public_methods to this value to count only user' methods. # nb_public_methods = 0 # for method in node.methods(): # if not method.name.startswith('_'): # nb_public_methods += 1 suppress_message(linter, MisdesignChecker.leave_classdef, "R0904", is_model_admin_subclass) # Tests suppress_message(linter, MisdesignChecker.leave_classdef, "R0904", is_model_test_case_subclass) # View # Method could be a function (get, post) suppress_message( linter, ClassChecker.leave_functiondef, "no-self-use", is_model_view_subclass_method_shouldnt_be_function, ) # django-mptt suppress_message( linter, DocStringChecker.visit_classdef, "missing-docstring", is_model_mpttmeta_subclass, ) pylint_newstyle_classdef_compat(linter, "old-style-class", is_model_mpttmeta_subclass) suppress_message(linter, ClassChecker.visit_classdef, "W0232", is_model_mpttmeta_subclass) suppress_message( linter, MisdesignChecker.leave_classdef, "too-few-public-methods", is_model_mpttmeta_subclass, ) # factory_boy's DjangoModelFactory suppress_message(linter, TypeChecker.visit_attribute, "no-member", is_model_factory) suppress_message( linter, ClassChecker.visit_functiondef, "no-self-argument", is_factory_post_generation_method, ) # wsgi.py suppress_message(linter, NameChecker.visit_assignname, "invalid-name", is_wsgi_application) apply_wrapped_augmentations()