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.
"""
full_name = "%s %s" % (self.first_name, self.last_name)
return full_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 generally readable, with clear class and method names, and logical organization. However, some formatting issues reduce clarity: inconsistent spacing and line breaks in field definitions (e.g., username, is_staff, is_active) disrupt reading flow. The nesting is flat, and each action is mostly on its own line, but some multiline arguments are awkwardly split. Intent is clear, but minor ambiguities exist due to formatting. Overall, it’s readable but could be improved with consistent formatting and cleaner line breaks.
Run 2
The code is moderately readable. Structure follows Django conventions, but formatting is inconsistent with excessive whitespace in some field definitions (e.g., username, is_staff) and cramped layouts in others. Several lines pack multiple arguments together, violating one-action-per-line and reducing clarity. The class methods are well-named and purposeful, but the class Meta block is cramped between fields and methods, disrupting reading flow. Some long help_text strings are awkwardly wrapped, making them harder to read. The overall organization is logical, but inconsistent spacing and argument formatting significantly impact readability.
Run 3
The code has decent logical organization but suffers from severe formatting inconsistencies that hurt readability. The AbstractUser class is well-structured with clear method separation, but many lines have excessive whitespace, misaligned parameters, and inconsistent indentation, making the code visually chaotic. For example, the username field's help_text has odd spacing and line breaks, and is_staff has parameters scattered across lines. Nesting is flat, which is good, and intent is mostly clear. However, the code length could be reduced with better formatting. Action granularity is generally one action per line, but the formatting makes it hard to follow. Reading flow is disrupted by these inconsistencies. The redundant email cleaning adds unnecessary complexity. Overall, the code could be significantly improved by applying consistent formatting standards (PEP 8) and removing the stray whitespace. The base structure is sound, but presentation undermines readability.
Run 1
Code Structure: The class logically groups model fields, configuration, metadata, and methods, although missing blank lines weaken separation. Nesting: Shallow nesting makes the code easy to follow; nested field arguments remain manageable. Clarity of intent: Descriptive names and docstrings clearly explain the user model and its methods, but undefined PermissionsMixin and UserManager references and unused imports introduce distractions. Code length: The implementation is reasonably concise, though the import list contains unnecessary entries. Action granularity: Methods generally perform one action per line, but several field declarations cram multiple arguments onto a single line. Reading flow: The progression from fields to behavior is natural, but inconsistent spacing, awkward line wrapping, and crowded declarations interrupt scanning.
Run 2
Code Structure: Fields, configuration, metadata, and methods are logically grouped, but unused imports and undefined PermissionsMixin and UserManager references distract. Nesting: Shallow nesting keeps the class easy to navigate. Clarity of intent: Descriptive names, field help text, and method docstrings clearly communicate the user model's purpose. Code length: The implementation is reasonably concise, although the import list adds unnecessary clutter. Action granularity: Methods generally perform one action per line, but several field arguments are crowded onto the same line with irregular spacing. Reading flow: The progression from fields to behavior is natural, yet inconsistent wrapping and missing blank lines between Meta, clean, and get_full_name interrupt scanning.
Run 3
Code Structure: Fields, configuration, metadata, and methods are logically grouped, but missing blank lines weaken separation. Nesting: Shallow nesting makes the class easy to follow; multiline field arguments are visually cluttered rather than deeply nested. Clarity of intent: Descriptive names and docstrings clearly convey a Django user model, although PermissionsMixin and UserManager are undefined in the provided snippet, and several imports are unused. Code length: Methods are concise, but unnecessary imports add noise. Action granularity: Methods generally perform one action per line, while multiple field arguments crowded onto single lines reduce scanability. Reading flow: The progression from fields to methods is natural, but irregular spacing, inconsistent wrapping, and cramped method boundaries interrupt reading.