Source code
from collections.abc import Iterable
from django.apps import apps
from django.contrib import auth
from django.contrib.auth.base_user import AbstractBaseUser, BaseUserManager
from django.contrib.auth.hashers import make_password
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import PermissionDenied
from django.core.mail import send_mail
from django.db import models
from django.db.models.manager import EmptyManager
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from .validators import UnicodeUsernameValidator
class AbstractUser(AbstractBaseUser, PermissionsMixin):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
Username and password are required. Other fields are optional.
"""
username_validator = UnicodeUsernameValidator()
username = models.CharField(
_("username"),
max_length=150,
unique=True,
help_text=_(
"Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."
),
validators=[username_validator],
error_messages={
"unique": _("A user with that username already exists."),
},
)
first_name = models.CharField(_("first name"), max_length=150, blank=True)
last_name = models.CharField(_("last name"), max_length=150, blank=True)
email = models.EmailField(_("email address"), blank=True)
is_staff = models.BooleanField(
_("staff status"),
default=False,
help_text=_("Designates whether the user can log into this admin site."),
)
is_active = models.BooleanField(
_("active"),
default=True,
help_text=_(
"Designates whether this user should be treated as active. "
"Unselect this instead of deleting accounts."
),
)
date_joined = models.DateTimeField(_("date joined"), default=timezone.now)
objects = UserManager()
EMAIL_FIELD = "email"
USERNAME_FIELD = "username"
REQUIRED_FIELDS = ["email"]
class Meta:
verbose_name = _("user")
verbose_name_plural = _("users")
abstract = True
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
"""
Return the first_name plus the last_name, with a space in between.
"""
return ("%s %s" % (self.first_name, self.last_name)).strip()
def get_short_name(self):
"""Return the short name for the user."""
return self.first_name
def email_user(self, subject, message, from_email=None, **kwargs):
"""Send an email to this user."""
send_mail(subject, message, from_email, [self.email], **kwargs)
Run 1
The code is largely readable and follows Django conventions well. It demonstrates clear structure, flat nesting, and natural reading flow, with field definitions organized logically. Intent is explicit through model fields and method names, and the code is concise. However, a few minor issues prevent a higher score: the get_full_name method contains an unnecessary blank line before the return, and some field definitions and help texts are quite verbose. The imports are slightly scattered but are mostly grouped. Overall, this is very readable Python/Django code.
Run 2
The code is highly readable. It follows a logical structure with clear separation of imports, model fields, Meta class, and methods. Nesting is minimal, with only one level used in field definitions and method bodies. The intent is explicit through descriptive names, docstrings, and Django conventions. Code length is appropriate; fields and methods are concise without sacrificing clarity. Each field and method performs a single action or represents a single concept, enhancing action granularity. Reading flow is natural: imports, class definition, fields, configuration, then methods. Minor deductions: the `get_full_name` method has a slightly awkward string formatting approach, and the import block is long but standard for Django models.
Run 3
The code exhibits strong readability overall. It is well-structured, with logical grouping of fields, configuration, and methods. Nesting is minimal, mostly limited to model field definitions and method bodies. The intent of each section and method is clear, aided by descriptive names and helpful docstrings. Code length is appropriate for an abstract user model, though the verbose Django field definitions add some length. Action granularity is generally one action per line, with each field and statement on its own line. Reading flow is natural, progressing from imports to class definition, fields, configuration, and finally methods. The code is clean and consistent, typical of production-quality Django code.
Run 1
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped; unused imports and unresolved PermissionsMixin/UserManager references slightly weaken the standalone presentation. Nesting: Shallow nesting and straightforward methods make scanning easy. Clarity of intent: Descriptive names, docstrings, and field help text clearly communicate the model's purpose. Code length: Mostly concise; multiline field declarations improve readability, though unused imports add clutter. Action granularity: Each statement performs a focused action, with no compressed sequences of unrelated operations. Reading flow: The progression from model definition to configuration and behavior is natural and consistent, with only minor formatting distractions.
Run 2
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped. Nesting: Shallow nesting makes the class easy to scan; multiline field declarations remain manageable. Clarity of intent: Descriptive names, docstrings, and field help text clearly communicate purpose, though PermissionsMixin and UserManager are not defined or imported in the snippet. Code length: Mostly concise, with useful declarative detail, but several unused imports add clutter. Action granularity: Statements generally perform one action each, with no compressed multi-statement lines. Reading flow: The progression from model definition to utility methods is natural and consistent. Minor whitespace issues and older string formatting slightly detract from an otherwise highly readable implementation.
Run 3
Code Structure: Fields, manager, configuration, metadata, and methods are logically grouped, though unused imports and undefined PermissionsMixin/UserManager references reduce self-contained clarity. Nesting: Shallow, with only standard class, method, and metadata nesting. Clarity of intent: Descriptive names, field help text, and concise docstrings clearly communicate the user model's purpose. Code length: Mostly concise; multiline field declarations improve readability, but unnecessary imports add clutter. Action granularity: Each statement performs a single clear action, with no compressed multi-action lines. Reading flow: Natural progression from model fields to configuration and behavior, supported by consistent formatting; a stray blank line and older string formatting are minor distractions.