Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:45
📄 __init__.py	0 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 external_django_tables2_noerror_meta_class.py # Check that Meta class definitions for django_tables2 classes # don't produce old-style-class warnings, see # https://github.com/PyCQA/pylint-django/issues/56 # pylint: disable=missing-docstring,too-few-public-methods import django_tables2 as tables from django.db import models class SimpleModel(models.Model): name = models.CharField() class SimpleTable(tables.Table): class Meta: model = SimpleModel	426 B	2026-01-20 12:58
📄 external_drf_noerror_serializer.py """ Checks that Pylint does not complain about DRF serializers """ # pylint: disable=C0111,W5101 from rest_framework import serializers class TestSerializerSubclass(serializers.ModelSerializer): class Meta: pass	228 B	2026-01-20 12:58
📄 external_drf_noerror_serializer.rc [testoptions] requires = rest_framework	40 B	2026-01-20 12:58
📄 external_factory_boy_noerror.py """ Test to validate that pylint_django doesn't produce Instance of 'SubFactory' has no 'pk' member (no-member) warnings """ # pylint: disable=attribute-defined-outside-init, missing-docstring, too-few-public-methods import factory from django import test from django.db import models class Author(models.Model): name = models.CharField() class Book(models.Model): title = models.CharField() author = models.ForeignKey(Author, related_name="books", on_delete=models.CASCADE) class AuthorFactory(factory.django.DjangoModelFactory): class Meta: model = "Author" name = factory.Sequence(lambda n: f"Author {n}") class BookFactory(factory.django.DjangoModelFactory): class Meta: model = "Book" title = factory.Sequence(lambda n: f"Book {n}") author = factory.SubFactory(AuthorFactory) reviewer = factory.LazyFunction(Author.objects.first()) class BookTestCase(test.LiveServerTestCase): serialized_rollback = True def _fixture_setup(self): super()._fixture_setup() self.book = BookFactory() _author = AuthorFactory() _first_book = _author.books.first() self.assertIsNotNone(_first_book) def test_author_is_not_none(self): self.assertGreater(self.book.pk, 0) self.assertGreater(self.book.author.pk, 0) self.assertIsNotNone(self.book.title) self.assertIsNotNone(self.book.author.name) def test_reviewer_is_not_none(self): self.assertGreater(self.book.reviewer.pk, 0)	1.49 KB	2026-01-20 12:58
📄 external_factory_boy_noerror.rc [testoptions] requires = factory	33 B	2026-01-20 12:58
📄 external_model_utils_noerror_override_manager.py # Check that when overriding the 'objects' attribite of a model class # with a manager from the django-model-utils package pylint-django # does not report not-an-iterator error, see # https://github.com/PyCQA/pylint-django/issues/117 # pylint: disable=missing-docstring, invalid-name from django.db import models from model_utils.managers import InheritanceManager class BaseModel(models.Model): name = models.CharField() class BuggyModel(models.Model): objects = InheritanceManager() name = models.CharField() def function(): for record in BaseModel.objects.all(): print(record.name) for record in BuggyModel.objects.all(): print(record.name) class Unit(models.Model): sim = models.CharField(max_length=64, null=True, blank=True) objects = InheritanceManager() installed_units = Unit.objects.filter(sim__isnull=False) ids = [u.sim for u in installed_units]	915 B	2026-01-20 12:58
📄 external_model_utils_noerror_override_manager.rc [testoptions] requires = model_utils	37 B	2026-01-20 12:58
📄 external_psycopg2_noerror_postgres_fields.py """ Checks that Pylint does not complain Postgres model fields. """ # pylint: disable=C0111,W5101 from __future__ import print_function from django.contrib.postgres import fields from django.db import models class PostgresFieldsModel(models.Model): arrayfield = fields.ArrayField(models.CharField()) hstorefield = fields.HStoreField() jsonfield = fields.JSONField() rangefield = fields.RangeField() integerrangefield = fields.IntegerRangeField() bigintegerrangefield = fields.BigIntegerRangeField() floatrangefield = fields.FloatRangeField() datetimerangefield = fields.DateTimeRangeField() daterangefield = fields.DateRangeField() def arrayfield_tests(self): sorted_array = self.arrayfield.sort() print(sorted_array) def dictfield_tests(self): print(self.hstorefield.keys()) print(self.hstorefield.values()) print(self.hstorefield.update({"foo": "bar"})) print(self.jsonfield.keys()) print(self.jsonfield.values()) print(self.jsonfield.update({"foo": "bar"})) def rangefield_tests(self): print(self.rangefield.lower) print(self.rangefield.upper) print(self.integerrangefield.lower) print(self.integerrangefield.upper) print(self.bigintegerrangefield.lower) print(self.bigintegerrangefield.upper) print(self.floatrangefield.lower) print(self.floatrangefield.upper) print(self.datetimerangefield.lower) print(self.datetimerangefield.upper) print(self.daterangefield.lower) print(self.daterangefield.upper)	1.59 KB	2026-01-20 12:58
📄 external_psycopg2_noerror_postgres_fields.rc [testoptions] requires = psycopg2	34 B	2026-01-20 12:58
📄 external_tastypie_noerror_foreign_key.py """ Checks that Pylint doesn't raise an error when a 'ForeignKey' appears in a non-django class The real case is described as follow: The project use tastypie and django. tastypie has a `ForeignKey` field which has the same name as django's `ForeignKey`. The issue is the lint trys resolving the `ForeignKey` for the tastypie `ForeignKey` which cause import error. """ from tastypie import fields from tastypie.fields import ForeignKey # pylint: disable=missing-docstring from tastypie.resources import ModelResource class MyTestResource(ModelResource): # pylint: disable=too-few-public-methods field1 = ForeignKey("myapp.api.resource", "xxx") field2 = fields.ForeignKey("myapp.api.resource", "xxx")	713 B	2026-01-20 12:58
📄 func_hard_coded_auth_user.py # pylint: disable=missing-docstring, wildcard-import, unused-wildcard-import # flake8: noqa=F401, F403 from django.contrib.auth.models import * # [imported-auth-user] from django.contrib.auth.models import User # [imported-auth-user] from django.db import models class PullRequest(models.Model): author = models.ForeignKey("auth.User", models.CASCADE) # [hard-coded-auth-user]	387 B	2026-01-20 12:58
📄 func_hard_coded_auth_user.txt imported-auth-user:4:0:4:40::User model imported from django.contrib.auth.models:UNDEFINED imported-auth-user:5:0:5:43::User model imported from django.contrib.auth.models:UNDEFINED hard-coded-auth-user:10:31:10:42:PullRequest:Hard-coded 'auth.User':UNDEFINED	260 B	2026-01-20 12:58
📄 func_json_response.py # pylint: disable=missing-docstring, line-too-long import json from django import http from django.http import HttpResponse def say_yes(): return HttpResponse(json.dumps({"rc": 0, "response": "ok"})) # [http-response-with-json-dumps] def say_yes2(): data = {"rc": 0, "response": "ok"} return http.HttpResponse(json.dumps(data)) # [http-response-with-json-dumps] def say_no(): return HttpResponse("no") def redundant_content_type(): data = {"rc": 0, "response": "ok"} return http.JsonResponse(data, content_type="application/json") # [redundant-content-type-for-json-response] def content_type_json(): json_data = "this comes from somewhere" return HttpResponse(json_data, content_type="application/json") # [http-response-with-content-type-json]	794 B	2026-01-20 12:58
📄 func_json_response.txt http-response-with-json-dumps:10:11:10:64:say_yes:Instead of HttpResponse(json.dumps(data)) use JsonResponse(data):UNDEFINED http-response-with-json-dumps:15:11:15:46:say_yes2:Instead of HttpResponse(json.dumps(data)) use JsonResponse(data):UNDEFINED redundant-content-type-for-json-response:24:11:24:67:redundant_content_type:Redundant content_type parameter for JsonResponse():UNDEFINED http-response-with-content-type-json:29:11:29:67:content_type_json:Instead of HttpResponse(content_type='application/json') use JsonResponse():UNDEFINED	542 B	2026-01-20 12:58
📄 func_model_does_not_use_unicode_py33.py """ Ensures that under PY3 django models with a __unicode__ method are flagged """ # pylint: disable=missing-docstring from django.db import models class SomeModel(models.Model): # [model-has-unicode] something = models.CharField(max_length=255) # no __str__ method something.something_else = 1 def lala(self): pass def __unicode__(self): return self.something	405 B	2026-01-20 12:58
📄 func_model_does_not_use_unicode_py33.txt model-has-unicode:9:0:9:15:SomeModel:Found __unicode__ method on model (SomeModel). Python3 uses __str__.:UNDEFINED	116 B	2026-01-20 12:58
📄 func_model_no_explicit_unicode_str_compat.py """ Ensures that django models with a __str__ method defined in an ancestor and python_2_unicode_compatible decorator applied are flagged correctly as not having explicitly defined __unicode__ """ # pylint: disable=missing-docstring from django.db import models from six import python_2_unicode_compatible @python_2_unicode_compatible class BaseModel(models.Model): def __str__(self): return "Foo" class SomeModel(BaseModel): # [model-no-explicit-unicode] pass	484 B	2026-01-20 12:58
📄 func_model_no_explicit_unicode_str_compat.txt model-no-explicit-unicode:18:0:18:15:SomeModel:Model does not explicitly define __unicode__ (SomeModel):UNDEFINED	114 B	2026-01-20 12:58
📄 func_modelform_exclude.py """ Checks that Pylint complains about ModelForm using exclude """ # pylint: disable=missing-docstring from django import forms class PersonForm(forms.ModelForm): class Meta: exclude = ("email",) # [modelform-uses-exclude]	239 B	2026-01-20 12:58
📄 func_modelform_exclude.txt modelform-uses-exclude:10:8:10:28:PersonForm.Meta:Use explicit fields instead of exclude in ModelForm:UNDEFINED	112 B	2026-01-20 12:58
📄 func_noerror_classviews.py """ Checks that Pylint does not complain about attributes and methods when using Class-based Views """ # pylint: disable=missing-docstring from django.db import models from django.http import JsonResponse from django.views.generic import DetailView, TemplateView, View from django.views.generic.edit import CreateView class BoringView(TemplateView): # ensure that args, kwargs and request are not thrown up as errors def get_context_data(self, *kwargs): return {"request": self.request, "args": self.args, "kwargs": self.kwargs} class JsonGetView(View): def get(self, request, args, *kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonPostView(View): def post(self, request, args, *kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonPutView(View): def put(self, request, args, *kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonPatchView(View): def patch(self, request, args, *kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonDeleteView(View): def delete(self, request, args, *kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonHeadView(View): def head(self, request, args, *kwargs): # pylint: disable=method-hidden # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonOptionsView(View): def options(self, request, args, *kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class JsonTraceView(View): def trace(self, request, args, kwargs): # do something with objects but don't use # self or request return JsonResponse({"rc": 0, "response": "ok"}) class Book(models.Model): name = models.CharField(max_length=100) good = models.BooleanField(default=False) class GetBook(DetailView): model = Book template_name = "books/get.html" http_method_names = ["get"] class CreateBook(CreateView): model = Book template_name = "books/new.html" def get_context_data(self, kwargs): context = super().get_context_data(**kwargs) context["page_title"] = "New book" return context	2.67 KB	2026-01-20 12:58
📄 func_noerror_duplicate_except_doesnotexist.py """ Checks that Pylint does not complain about duplicate except blocks catching DoesNotExist exceptions: https://github.com/PyCQA/pylint-django/issues/81 """ # pylint: disable=missing-docstring from django.db import models class Book(models.Model): name = models.CharField(max_length=100) class Author(models.Model): name = models.CharField(max_length=100) def dummy_func(): try: print("foo") except Book.DoesNotExist: print("bar") except Author.DoesNotExist: print("baz")	524 B	2026-01-20 12:58
📄 func_noerror_factory_post_generation.py """ Checks that Pylint does not complain about no self argument in factory.post_generation method. """ # pylint: disable=missing-docstring,too-few-public-methods,unused-argument,no-member import factory class SomeModelFactory(factory.Factory): class Meta: pass @factory.post_generation def action(obj, create, extracted, **kwargs): if extracted: obj.do_action() obj.save()	425 B	2026-01-20 12:58
📄 func_noerror_foreign_key_attributes.py """ Checks that Pylint does not complain about foreign key sets on models """ # pylint: disable=missing-docstring consider-using-f-string from django.db import models class SomeModel(models.Model): name = models.CharField(max_length=20) timestamp = models.DateTimeField() class OtherModel(models.Model): something = models.ForeignKey(SomeModel, on_delete=models.CASCADE) elsething = models.OneToOneField(SomeModel, on_delete=models.CASCADE) def something_doer(self): part_a = f"{self.something.name} - {self.something.timestamp}" part_b = self.elsething.name return part_a, part_b	632 B	2026-01-20 12:58
📄 func_noerror_foreign_key_ids.py """ Checks that Pylint does not complain about foreign key id access """ # pylint: disable=missing-docstring,wrong-import-position from django.db import models class SomeModel(models.Model): count = models.IntegerField() class SomeOtherModel(models.Model): some_model = models.ForeignKey(SomeModel, on_delete=models.CASCADE) number = models.IntegerField() def do_something(self): self.number = self.some_model_id	443 B	2026-01-20 12:58
📄 func_noerror_foreign_key_key_cls_unbound.py """ Checks that Pylint does not complain about ForeignKey pointing to model in module of models package """ # pylint: disable=missing-docstring from django.db import models class FairyTail(models.Model): # fails with "UnboundLocalError: local variable 'key_cls' referenced before assignment" author = models.ForeignKey(to="input.Author", null=True, on_delete=models.CASCADE) def get_author_name(self): return self.author.id	447 B	2026-01-20 12:58
📄 func_noerror_foreign_key_package.py """ Checks that Pylint does not complain about ForeignKey pointing to model in module of models package """ # pylint: disable=missing-docstring from django.db import models class Book(models.Model): author = models.ForeignKey(to="pylint_django.tests.input.Author", on_delete=models.CASCADE) def get_author_name(self): return self.author.id	359 B	2026-01-20 12:58
📄 func_noerror_foreign_key_sets.py """ Checks that Pylint does not complain about foreign key sets on models """ # pylint: disable=missing-docstring from django.db import models class SomeModel(models.Model): name = models.CharField(max_length=20) def get_others(self): return self.othermodel_set.all() def get_first(self): return self.othermodel_set.first() def othermodel_update_or_create(self): return self.othermodel_set.update_or_create() class OtherModel(models.Model): count = models.IntegerField() something = models.ForeignKey(SomeModel, on_delete=models.CASCADE) class ThirdModel(models.Model): whatever = models.ForeignKey(SomeModel, related_name="whatevs", on_delete=models.CASCADE) def count_whatevers(): if SomeModel().whatevs.exists(): return SomeModel().whatevs.count() return -1	842 B	2026-01-20 12:58
📄 func_noerror_foreignkeys.py """ Checks that Pylint does not complain about various methods on Django model fields. """ # pylint: disable=missing-docstring,wrong-import-position from django.db import models from django.db.models import ForeignKey, OneToOneField class Genre(models.Model): name = models.CharField(max_length=100) class Author(models.Model): author_name = models.CharField(max_length=100) class ISBN(models.Model): value = models.CharField(max_length=100) class Book(models.Model): book_name = models.CharField(max_length=100) # Check this works with and without `to` keyword author = models.ForeignKey(to="Author", on_delete=models.CASCADE) isbn = models.OneToOneField(to=ISBN, on_delete=models.CASCADE) genre = models.ForeignKey(Genre, on_delete=models.CASCADE) def get_isbn(self): return self.isbn.value def get_author_name(self): return self.author.author_name class Fruit(models.Model): fruit_name = models.CharField(max_length=20) class Seed(models.Model): fruit = ForeignKey(to=Fruit, on_delete=models.CASCADE) def get_fruit_name(self): return self.fruit.fruit_name class User(models.Model): username = models.CharField(max_length=32) class UserProfile(models.Model): user = OneToOneField(User, on_delete=models.CASCADE) def get_username(self): return self.user.username class Human(models.Model): child = ForeignKey("self", on_delete=models.SET_NULL, null=True) parent = ForeignKey(to="self", on_delete=models.SET_NULL, null=True) def get_grandchild(self): return self.child.child def get_grandparent(self): return self.parent.parent class UserPreferences(models.Model): """ Used for testing FK which refers to another model by string, not model class, see https://github.com/PyCQA/pylint-django/issues/35 """ user = ForeignKey("User", on_delete=models.CASCADE) class UserAddress(models.Model): user = OneToOneField(to="User", on_delete=models.CASCADE) line_1 = models.CharField(max_length=100) line_2 = models.CharField(max_length=100) city = models.CharField(max_length=100) postal_code = models.CharField(max_length=100)	2.17 KB	2026-01-20 12:58
📄 func_noerror_form_fields.py """ Checks that Pylint does not complain about various methods on Django form forms. """ # pylint: disable=missing-docstring from __future__ import print_function from datetime import date, datetime from django import forms from django.contrib.auth.forms import UserCreationForm class ManyFieldsForm(forms.Form): booleanfield = forms.BooleanField() charfield = forms.CharField(max_length=40, null=True) datetimefield = forms.DateTimeField(auto_now_add=True) datefield = forms.DateField(auto_now_add=True) decimalfield = forms.DecimalField(max_digits=5, decimal_places=2) durationfield = forms.DurationField() emailfield = forms.EmailField() filefield = forms.FileField(name="test_file", upload_to="test") filepathfield = forms.FilePathField(path="/some/path") floatfield = forms.FloatField() genericipaddressfield = forms.GenericIPAddressField() imagefield = forms.ImageField(name="test_image", upload_to="test") intfield = forms.IntegerField(null=True) nullbooleanfield = forms.NullBooleanField() slugfield = forms.SlugField() timefield = forms.TimeField() urlfield = forms.URLField() def boolean_field_tests(self): print(self.booleanfield \| True) print(self.nullbooleanfield \| True) def string_field_tests(self): print(self.charfield.strip()) print(self.charfield.upper()) print(self.charfield.replace("x", "y")) print(self.filepathfield.strip()) print(self.filepathfield.upper()) print(self.filepathfield.replace("x", "y")) print(self.emailfield.strip()) print(self.emailfield.upper()) print(self.emailfield.replace("x", "y")) def datetimefield_tests(self): now = datetime.now() print(now - self.datetimefield) print(self.datetimefield.ctime()) def datefield_tests(self): now = date.today() print(now - self.datefield) print(self.datefield.isoformat()) def decimalfield_tests(self): print(self.decimalfield.adjusted()) def durationfield_tests(self): now = datetime.now() print(now - self.durationfield) print(self.durationfield.total_seconds()) def filefield_tests(self): print(self.filefield) print(self.imagefield) def numberfield_tests(self): print(self.intfield + 5) _ = UserCreationForm.declared_fields	2.36 KB	2026-01-20 12:58
📄 func_noerror_forms_py33.py """ Checks that Pylint does not complain about django Forms """ # pylint: disable=missing-docstring,wrong-import-position from django import forms class TestForm(forms.Form): class Meta: pass some_field = forms.CharField() def clean(self): print(self.cleaned_data) print(self.fields) print(self.error_class) class TestModelForm(forms.ModelForm): class Meta: pass class TestFormSubclass(forms.Form): class Meta: pass class TestModelFormSubclass(forms.ModelForm): class Meta: pass class TestFormWidgetAssignment(forms.Form): multi_field = forms.MultipleChoiceField(choices=[("1", "First"), ("2", "Second")]) class Meta: widgets = {} widgets["multi_field"] = forms.CheckboxSelectMultiple	805 B	2026-01-20 12:58
📄 func_noerror_formview_ancestors.py """ Checks that Pylint does not complain about django FormViews having too many ancestors """ # pylint: disable=missing-docstring from django.views.generic import FormView class SomeView(FormView): pass	210 B	2026-01-20 12:58
📄 func_noerror_generic_foreign_key.py """ Checks that Pylint does not complain about GenericForeignKey fields: https://github.com/PyCQA/pylint-django/issues/230 """ # pylint: disable=missing-docstring from django.contrib.contenttypes.fields import GenericForeignKey from django.contrib.contenttypes.models import ContentType from django.db import models class Ownership(models.Model): # for #230 the important bit is this FK field which doesn't # have any keyword arguments! owner_type = models.ForeignKey(ContentType, models.CASCADE) owner_id = models.PositiveIntegerField() owner = GenericForeignKey("owner_type", "owner_id")	613 B	2026-01-20 12:58
📄 func_noerror_gettext_lazy_format.py """ Checks that Pylint does not complain about django lazy proxy when using gettext_lazy """ from django.utils.translation import gettext_lazy gettext_lazy("{something}").format(something="lala")	197 B	2026-01-20 12:58
📄 func_noerror_ignore_meta_subclass.py """ This test ensures that a 'Meta' class defined on a Django model does not raise warnings such as 'old-style-class' and 'too-few-public-methods' """ # pylint: disable=missing-docstring from django.db import models class SomeModel(models.Model): class Meta: ordering = ("-id",)	295 B	2026-01-20 12:58
📄 func_noerror_import_q.py """ Checks that Pylint does not complain about import of Q. """ # pylint: disable=missing-docstring,unused-import from django.db.models import Q # noqa: F401	160 B	2026-01-20 12:58
📄 func_noerror_issue_46.py """ Checks that Pylint does not complain about raising DoesNotExist """ # pylint: disable=missing-docstring from django.db import models class SomeModel(models.Model): pass raise SomeModel.DoesNotExist	211 B	2026-01-20 12:58
📄 func_noerror_managers_return_querysets.py """ Checks that Pylint does not complain about Manager methods returning lists when they in fact return QuerySets """ from django.db import models class SomeModelQuerySet(models.QuerySet): """A missing docstring""" @staticmethod def public_method(): """A missing docstring""" return 1 class SomeModelManager(models.Manager): """A missing docstring""" @staticmethod def public_method(): """A missing docstring""" return 1 @staticmethod def another_public_method(): """A missing docstring""" return 1 class SomeModel(models.Model): """A missing docstring""" name = models.CharField(max_length=20) datetimestamp = models.DateTimeField() objects = SomeModelManager() class OtherModel(models.Model): """A missing docstring""" name = models.CharField(max_length=20) somemodel = models.ForeignKey(SomeModel, on_delete=models.CASCADE, null=False) def call_some_querysets(): """A missing docstring""" not_a_list = SomeModel.objects.filter() not_a_list.values_list("id", flat=True)	1.08 KB	2026-01-20 12:58
📄 func_noerror_manytomanyfield.py """ Checks that Pylint does not complain about various methods on many-to-many relationships """ from django.contrib.auth.models import AbstractUser, Permission # pylint: disable=missing-docstring from django.db import models class Book(models.Model): name = models.CharField(max_length=100) good = models.BooleanField(default=False) class Author(models.Model): name = models.CharField(max_length=100) wrote = models.ManyToManyField(Book, verbose_name="Book", related_name="books") def get_good_books(self): return self.wrote.filter(good=True) def is_author_of(self, book): return book in list(self.wrote.all()) def wrote_how_many(self): return self.wrote.count() # Custom permissions for CustomUser USER_PERMS = ["change_customuser", "add_customuser"] class CustomUser(AbstractUser): # pylint: disable=model-no-explicit-unicode class Meta: verbose_name = "CustomUser" verbose_name_plural = "CustomUsers" app_label = "users" def grant_permissions(self): """Example adding permissions to User""" self.user_permissions.clear() for perm in USER_PERMS: perm = Permission.objects.get(codename=perm) self.user_permissions.add(perm) return self.user_permissions def add_permission(self, permission): self.user_permissions.add(permission) def remove_permission(self, permission): self.user_permissions.remove(permission) def set_permissions(self, permissions): self.user_permissions.set(permissions) def save(self, args, *kwargs): """Saving while granting new permissions""" self.is_staff = True super().save() self.grant_permissions()	1.72 KB	2026-01-20 12:58
📄 func_noerror_model_fields.py """ Checks that Pylint does not complain about various methods on Django model fields. """ # pylint: disable=missing-docstring from __future__ import print_function from datetime import date, datetime from decimal import Decimal from django.db import models class LotsOfFieldsModel(models.Model): bigintegerfield = models.BigIntegerField() booleanfield = models.BooleanField(default=True) charfield = models.CharField(max_length=40, null=True) commaseparatedintegerfield = models.CommaSeparatedIntegerField() datetimefield = models.DateTimeField(auto_now_add=True) datefield = models.DateField(auto_now_add=True) decimalfield = models.DecimalField(max_digits=5, decimal_places=2) durationfield = models.DurationField() emailfield = models.EmailField() filefield = models.FileField(name="test_file", upload_to="test") filepathfield = models.FilePathField() floatfield = models.FloatField() genericipaddressfield = models.GenericIPAddressField() imagefield = models.ImageField(name="test_image", upload_to="test") ipaddressfield = models.IPAddressField() intfield = models.IntegerField(null=True) nullbooleanfield = models.NullBooleanField() positiveintegerfield = models.PositiveIntegerField() positivesmallintegerfield = models.PositiveSmallIntegerField() slugfield = models.SlugField() smallintegerfield = models.SmallIntegerField() textfield = models.TextField() timefield = models.TimeField() urlfield = models.URLField() def __str__(self): return self.id def boolean_field_tests(self): print(self.booleanfield \| True) print(self.nullbooleanfield \| True) def string_field_tests(self): print(self.charfield.strip()) print(self.charfield.upper()) print(self.charfield.replace("x", "y")) print(self.filepathfield.strip()) print(self.filepathfield.upper()) print(self.filepathfield.replace("x", "y")) print(self.emailfield.strip()) print(self.emailfield.upper()) print(self.emailfield.replace("x", "y")) print(self.textfield.strip()) print(self.textfield.upper()) print(self.textfield.replace("x", "y")) def datetimefield_tests(self): now = datetime.now() print(now - self.datetimefield) print(self.datetimefield.ctime()) def datefield_tests(self): now = date.today() print(now - self.datefield) print(self.datefield.isoformat()) def decimalfield_tests(self): print(self.decimalfield.compare(Decimal("1.4"))) def durationfield_tests(self): now = datetime.now() print(now - self.durationfield) print(self.durationfield.total_seconds()) def filefield_tests(self): self.filefield.save("/dev/null", "TEST") print(self.filefield.file) self.imagefield.save("/dev/null", "TEST") print(self.imagefield.file) def numberfield_tests(self): print(self.intfield + 5) print(self.bigintegerfield + 4) print(self.smallintegerfield + 3) print(self.positiveintegerfield + 2) print(self.positivesmallintegerfield + 1)	3.14 KB	2026-01-20 12:58
📄 func_noerror_model_methods.py """ Checks that Pylint does not complain about using Model and Manager methods """ # pylint: disable=missing-docstring from django.db import models class SomeModel(models.Model): name = models.CharField(max_length=64) if __name__ == "__main__": MODEL = SomeModel() MODEL.save() MODEL.delete() COUNT = SomeModel.objects.count() # added in django 1.6 FIRST = SomeModel.objects.first() LAST = SomeModel.objects.last() DB_RECORD, CREATED = SomeModel.objects.get_or_create(name="Tester") EXCLUDED_IDS = [obj.pk for obj in SomeModel.objects.exclude(name__isnull=True)]	610 B	2026-01-20 12:58
📄 func_noerror_model_objects.py # Test that defining `objects` as a regular model manager # doesn't raise issues, see # https://github.com/PyCQA/pylint-django/issues/144 # # pylint: disable=missing-docstring from django.db import models class ModelWithRegularManager(models.Model): objects = models.Manager() name = models.CharField() def function(): record = ModelWithRegularManager.objects.all()[0] for record in ModelWithRegularManager.objects.all(): print(record.name)	472 B	2026-01-20 12:58
📄 func_noerror_model_unicode_callable.py """ Ensures that django models without a __unicode__ method are flagged """ # pylint: disable=missing-docstring,wrong-import-position from django.db import models def external_unicode_func(model): return model.something class SomeModel(models.Model): something = models.CharField(max_length=255) __unicode__ = external_unicode_func	350 B	2026-01-20 12:58
📄 func_noerror_model_unicode_lambda.py """ Ensures that django models without a __unicode__ method are flagged """ # pylint: disable=missing-docstring,wrong-import-position from django.db import models class SomeModel(models.Model): something = models.CharField(max_length=255) __unicode__ = lambda s: str(s.something) # noqa: E731	306 B	2026-01-20 12:58
📄 func_noerror_models_py33.py """ Checks that Pylint does not complain about a fairly standard Django Model """ # pylint: disable=missing-docstring from django.db import models class SomeModel(models.Model): class Meta: pass some_field = models.CharField(max_length=20) other_fields = models.ManyToManyField("AnotherModel") def stuff(self): try: print(self._meta) print(self.other_fields.all()[0]) except self.DoesNotExist: print("does not exist") except self.MultipleObjectsReturned: print("lala") print(self.get_some_field_display()) class SubclassModel(SomeModel): class Meta: pass	680 B	2026-01-20 12:58
📄 func_noerror_protected_meta_access.py """ Tests to make sure that access to _meta on a model does not raise a protected-access warning, as it is part of the public API since Django 1.8 (see https://github.com/PyCQA/pylint-django/issues/66, and https://docs.djangoproject.com/en/1.9/ref/models/meta/) """ # pylint: disable=missing-docstring from __future__ import print_function from django.db import models class ModelWhichLikesMeta(models.Model): ursuary = models.BooleanField(default=False) def do_a_thing(self): return self._meta.get_field("ursuary") if __name__ == "__main__": MODEL = ModelWhichLikesMeta() MODEL.save() print(MODEL._meta.get_field("ursuary")) print(MODEL.do_a_thing())	691 B	2026-01-20 12:58
📄 func_noerror_string_foreignkey.py """ Checks that PyLint correctly handles string foreign keys https://github.com/PyCQA/pylint-django/issues/243 """ # pylint: disable=missing-docstring, hard-coded-auth-user from django.db import models class Book(models.Model): author = models.ForeignKey("test_app.Author", models.CASCADE) user = models.ForeignKey("auth.User", models.PROTECT)	354 B	2026-01-20 12:58
📄 func_noerror_style_members.py # Test that using `color_style` or `no_style` # doesn't raise no-member error # # pylint: disable=missing-docstring from django.core.management.color import color_style, no_style def function(): style = color_style() print(style.SUCCESS("test")) style = no_style() print(style.SUCCESS("test"))	314 B	2026-01-20 12:58
📄 func_noerror_test_wsgi_request.py """ Checks that Pylint does not complain about a standard test. See: https://github.com/PyCQA/pylint-django/issues/78 """ from django.db import models from django.test import TestCase class SomeModel(models.Model): """Just a model.""" class SomeTestCase(TestCase): """A test cast.""" def test_thing(self): """Test a thing.""" expected_object = SomeModel() response = self.client.get("/get/some/thing/") self.assertEqual(response.status_code, 200) self.assertEqual(response.context["object"], expected_object)	567 B	2026-01-20 12:58
📄 func_noerror_ugettext_lazy_format.py """ Checks that Pylint does not complain about django lazy proxy when using ugettext_lazy """ from django.utils.translation import ugettext_lazy ugettext_lazy("{something}").format(something="lala")	200 B	2026-01-20 12:58
📄 func_noerror_unicode_py2_compatible.py """ Ensures that no '__unicode__ missing' warning is emitted if the Django python3/2 compatability decorator is used See https://github.com/PyCQA/pylint-django/issues/10 """ from django.db import models # pylint: disable=missing-docstring from six import python_2_unicode_compatible @python_2_unicode_compatible class ModelName(models.Model): name = models.CharField(max_length=200) def __str__(self): return self.name	441 B	2026-01-20 12:58
📄 func_noerror_urls.py """ Checks that Pylint does not complain about attributes and methods when creating a typical urls.py """ # pylint: disable=missing-docstring try: # to be able to test django versions from 1.11 - 3.2 from django.urls import path except ImportError: from django.conf.urls import url as path from django.views.generic import TemplateView class BoringView(TemplateView): pass urlpatterns = [ path(r"^something", BoringView.as_view(), name="something"), ]	478 B	2026-01-20 12:58
📄 func_noerror_uuid_field.py """ Checks that Pylint does not complain about UUID fields. """ # pylint: disable=missing-class-docstring,missing-function-docstring from __future__ import print_function from django.db import models class LotsOfFieldsModel(models.Model): uuidfield = models.UUIDField() def uuidfield_tests(self): print(self.uuidfield.bytes) print(self.uuidfield.bytes_le) print(self.uuidfield.fields[2]) print(self.uuidfield.hex) # print(self.uuidfield.int) # Don't know how to properly check this one print(self.uuidfield.variant) print(self.uuidfield.version)	616 B	2026-01-20 12:58
📄 func_noerror_views.py """ Checks that Pylint does not complain when using function based views. """ # pylint: disable=missing-docstring def empty_view(request): pass	151 B	2026-01-20 12:58
📄 func_noerror_wsgi.py """ Standard WSGI config created by django-admin startproject. Used to verify pylint_django doesn't produce invalid-name for the application variable. See: https://github.com/PyCQA/pylint-django/issues/77 """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "testproj.settings") application = get_wsgi_application()	380 B	2026-01-20 12:58
📄 func_unused_arguments.py """ Checks that Pylint still complains about unused-arguments for other arguments if a function/method contains an argument named `request`. """ # pylint: disable=missing-docstring from django.http import JsonResponse from django.views import View # Pylint generates the warning `redefined-outer-name` if an argument name shadows # a variable name from an outer scope. But if that argument name is ignored this # warning will not be generated. # Therefore define request here to cover this behaviour in this test case. request = None # pylint: disable=invalid-name def user_detail(request, user_id): # [unused-argument] # nothing is done with user_id return JsonResponse({"username": "steve"}) class UserView(View): def get(self, request, user_id): # [unused-argument] # nothing is done with user_id return JsonResponse({"username": "steve"}) # The following views are already covered in other test cases. # They are included here for completeness sake. def welcome_view(request): # just don't use `request' b/c we could have Django views # which never use it! return JsonResponse({"message": "welcome"}) class CBV(View): def get(self, request): return JsonResponse({"message": "hello world"})	1.23 KB	2026-01-20 12:58
📄 func_unused_arguments.txt unused-argument:18:25:18:32:user_detail:Unused argument 'user_id':HIGH unused-argument:24:27:24:34:UserView.get:Unused argument 'user_id':INFERENCE	148 B	2026-01-20 12:58
📁 migrations	-	2026-03-21 15:45
📁 models	-	2026-03-21 15:45
📁 test_app	-	2026-03-21 15:45

Edit File:

Terminal